Kortix vs NanoClaw: a personal agent or an open-source system a company owns

NanoClaw is a lightweight personal AI agent that runs every session in its own Docker container and meets you in the chat apps you already use. Kortix is the open-source AI Operating System a team owns: your agents, skills, company memory, and connectors live in one git repo, and a person merges each change before it reaches the default branch. Both are open source, and both let you bring your own model. The separation between them is what each is built to hold: one person's private agent, or a workforce a company governs.

What NanoClaw is good at

NanoClaw is a small, security-first agent harness from NanoCo, and it has grown fast. Its repository shows 30,937 GitHub stars, checked October 2026 (NanoClaw on GitHub), and it is MIT-licensed. Its own site describes the same core functionality as larger claws in a codebase a person can read in an afternoon (NanoClaw).

• Every session is isolated. Each active session runs in its own Docker container and can only see what is explicitly mounted, on macOS, Linux, or Windows through WSL2 (NanoClaw).
• The core is small on purpose. One Node host process routes each message, with no microservices and no message brokers, so you can trace a message from the channel to the agent and back (NanoClaw on GitHub).
• Agents do not hold raw keys. Outbound HTTPS routes through a credential gateway that injects credentials at request time and enforces per-agent policies and rate limits, and NanoClaw ships with OneCLI's Agent Vault behind a provider seam (NanoClaw on GitHub).
• It reaches the chats you use. WhatsApp, Telegram, Discord, Slack, Microsoft Teams, iMessage, Matrix, Google Chat, Webex, Linear, GitHub, WeChat, and email through Resend, each added on demand (NanoClaw on GitHub).
• The model is a per-agent choice. Claude is the default through Anthropic's Claude Agent SDK, with Codex, OpenCode, and Ollama as drop-in providers (NanoClaw on GitHub).

That combination is tuned for a single operator running one agent on their own machine.

Where a personal agent stops for a team

NanoClaw is built for one person, and its own material is explicit about that. The repository states that NanoClaw has no user accounts, and the design notes describe software shaped to one user's exact needs rather than a multi-tenant platform (NanoClaw on GitHub).

• There is one configuration. Customization means code changes to your own fork, so there is no shared company repo that a team diffs and reviews together.
• There is no org-wide gate. An agent acts in the tools you connect it to, and nothing routes that action past a colleague before it takes effect.
• There are no seats or roles. With no user accounts, there is no per-resource permission or audit trail that a security team can present to an auditor.
• Memory stays per group. Each agent group keeps its own workspace and memory, and separate groups do not share one, so what the company learns sits in a single operator's fork.
• It is one host. A single Node process on your machine is the whole system, and the machine is where the agent runs.

None of that is a flaw in NanoClaw, which is a personal agent and good at being one. Those qualities are exactly what a company cannot accept once more than one person steers the agent.

One repo that is the company

Kortix starts from the opposite unit: a team, with a git repo at the center. In a Kortix project, agents are markdown files, skills are markdown plus scripts, company memory is plain files, and the connectors, triggers, and machine image are declared in kortix.yaml. The repo is the company, and you can grep all of it (Kortix on GitHub).

agents:
  support-triage:
    file: agents/support-triage.md
    connectors: all

An agent is a markdown persona plus a scoped reach into tools, and the scope lives in the same repo a reviewer can comment on. kortix.yaml declares the machine image, the connectors and triggers, and the secret names and grants, while secret values never appear in the repo. Because the configuration is text, a team diffs a change to an agent's permissions or its memory the same way it reviews any other code.

One machine per session, one review per change

Kortix is built so that work is reviewed before it lands. Each session gets its own isolated sandbox on its own branch, and thousands of agents run in parallel on one config without crossover. When the work is ready, the agent opens a change request against the default branch, a person reads the diff and merges it, and merge is default-deny for agents (Kortix on GitHub).

• Per-resource permissions for people and agents. Roles, groups, and an audit trail cover humans and agents as principals (Kortix on GitHub).
• Any model, your keys. Bring a provider key, use the ChatGPT plan you already pay for, or sign in with your OpenCode Console account.
• Every tool call is scoped. Set each connector action to Allow, Ask, or Block down to the arguments of a call, and connector credentials are brokered server-side so they never enter the machine.
• It runs where you need it. Kortix Cloud, your VPC, or your own on-prem network, with self-host free. Slack and Microsoft Teams are live, with email experimental per project.

NanoClaw keeps one operator's agent private on their own machine. Kortix keeps a team's agents in a setup the team can audit, because it is the same repo the work lands in.

Where NanoClaw is the better pick

If you are one person who wants a private agent on your own machine, NanoClaw is the lighter answer. It installs on macOS, Linux, or Windows through WSL2, reaches a dozen chat surfaces, and keeps its state and keys on your hardware with no account to create. Nothing in it asks you to think about seats, roles, or a review gate, which is exactly what personal use wants.

Side by side

When to pick which

Pick NanoClaw when you are one person running an agent for yourself and you want the smallest codebase you can fork and shape. Pick Kortix when a team has to run agents together, because the configuration is a repo people review and the permissions, audit, and change-request gate exist for more than one person steering the work.

The unit is the difference. NanoClaw optimizes for one operator and their machine, and Kortix optimizes for a workforce a company owns and reviews.

If you want the personal-assistant comparison, Kortix vs OpenClaw covers the assistant side, and Personal AI agents vs a company OS draws the line between one operator and a whole company.

Free to start, free to self-host. Try Kortix.