Where Pi and Claude Code stop, and the open-source runtime starts

What Pi does right, and what it hands back to you

Pi is a minimal agent harness from Earendil Inc.; Mario Zechner created it. Its tagline on pi.dev (28 October 2026) is "Adapt Pi to your workflows, not the other way around." Four tools come built in: read, write, edit and bash. It runs in four modes (interactive, print/JSON, RPC and the SDK) and switches models mid-session with /model. Provider keys come from the environment, so Anthropic, OpenAI, Google, Bedrock, Mistral, Groq and more are reachable.

Sessions are stored as trees. /tree goes back to any earlier point in one file, /export writes the transcript as HTML, and /share uploads a gist. That is a lot of harness for a developer who wants the loop small and every part of it theirs.

The small core is deliberate. Pi "ships with powerful defaults but skips features like sub-agents and plan mode", and missing pieces arrive as extensions, skills, prompt templates and themes, bundled as Pi packages and shared through npm or git. Pi says it plainly: "Features that other agents bake in, you can build yourself." A permission layer sits on that list, which makes it a package you install rather than a guarantee the harness gives you.

Its README is just as direct about the boundary: "Pi does not include a built-in permission system for restricting filesystem, process, network, or credential access. By default, it runs with the permissions of the user and process that launched it." Pi names three isolation patterns for people who need more than that, and all three are wiring you do yourself.

What Claude Code gets right

Claude Code is Anthropic's coding agent. It works where developers already are: the terminal, VS Code and JetBrains, the browser, the mobile app or Claude on the desktop. It runs on macOS, Linux and Windows (claude.com, 28 October 2026). In a terminal it "runs locally and talks directly to model APIs without requiring a backend server or remote code index". It also "asks for permission before making changes to your files or running commands". That prompt is what most people mean when they call a coding agent safe to leave running.

Claude Code runs Anthropic's Claude models and can call command-line tools like Git and MCP servers like GitHub. It plans the work, writes code, runs tests and opens pull requests. Access comes through a Pro, Max, Team or Enterprise plan or a Claude Console account. Team adds self-serve seat management and up to $500 per month in pooled API credits. Enterprise adds RBAC, spend limits, usage analytics and custom data controls.

Where the two are the same

Both are harnesses: a model, a tool loop and a place to type. Driven from a terminal or an IDE, both run under one person's supervision, and both assume that person is watching the session. Pi always runs on the machine that launched it. Claude Code runs locally when you drive it from your terminal, and its browser and mobile sessions run on Anthropic's side. Pi trusts the environment it was launched in; Claude Code asks at the moment of each change. Either way the approval is a conversation between one person and one session.

For one developer that shape works. A team hits the edges quickly. Whose machine holds the checkout? Who writes down the rule that stops rm -rf when the session belongs to a new hire? Who signs off the merge before it reaches main, and where is the record that they did? The rest of the difference comes from what sits around the harness, and what a harness is covers that boundary in plain terms.

The third column, when the harness is pi

Kortix runs pi as its harness. Every new session starts it, and the runtime supplies the machine, the rules and the merge gate. Kortix is open source: read it, fork it, audit it.

A machine and a branch for every session

Each session has its own isolated machine and branch. The sandbox clones the repo to /workspace and starts pi there. The branch is named with the session id, so two sessions never share a checkout and nothing runs on your laptop. That is the difference between a harness on a laptop and running pi in the cloud.

Rules you can read in the repo

Permission is a field in the agent's file, not a prompt the model is asked to respect. Every tool takes allow, ask or deny, and the file tools and bash also take patterns:

permission:  edit: allow  bash:    "*": ask    "git status": allow    "git diff *": allow    "git log *": allow    "rm -rf *": deny  webfetch: ask

The most specific pattern wins, so git diff * can sit beside * without you ordering the keys, and a recursive delete is refused by name. Read the docs lists every field and what a rule does to a running turn.

A person merges the diff

Session work reaches main through a change request. Merge is default-deny for agents. The branch is named with the session id and the agent commits and pushes to it, then opens the change request. A person reviews and merges it, in the order Kortix documents. Connector credentials are brokered server-side and never enter the machine, so a session can use a connected app without holding its key.

When each one is the right call

Pick Claude Code for a terminal and a person at the keyboard

Claude Code suits a developer who works in a terminal or an IDE on their own machine. It runs Claude models in a client Anthropic maintains. Answering its permission prompt takes less work than writing a rule file.

Pick pi on its own for a harness you can reshape

Pi suits the developer who wants the smallest loop they can rebuild: their own provider keys, their own extensions, their own laptop, one session at a time.

For a team, the runtime is the decision

Either harness still leaves a team to answer where each session runs, how one rule applies to every member, and who signs off the merge. Kortix answers those and keeps pi as the harness, which is why Kortix is the recommendation for teams rather than for every reader. If the word harness is still fuzzy, the Pi coding agent guide starts at the definition.