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

> Pi is a minimal harness you run yourself. Claude Code is Anthropic's coding agent: it asks before it changes your files and runs in the terminal, IDE and browser. For a team, the gap is an isolated machine per session, rules written once and a merge gate. Kortix is open source, runs pi underneath and supplies those three.

URL: https://picodingagentguide.com/pi-coding-agent-vs-claude-code

Pi and Claude Code, and what runs either one

**The open-source AI Operating System**

`terminal`

```sh
$ kortix sessions new -p "Fix the failing test in src/billing and open a change request" --wait
$ kortix sessions pending <session_id>
```

Source: https://kortix.com/docs/work/sessions

One isolated sandbox per session: each session has its own isolated machine and branch.

[Try Kortix](https://kortix.com) · [Read the comparison](https://picodingagentguide.com/#compare)

Pi in every new session · Rules in the agent file · A person merges

## Kortix, Pi and Claude Code on the rows a team lives with

Pi and Claude Code are harnesses you drive; Kortix is the runtime that runs pi and holds the machine, the team rules and the merge gate.

| | Kortix (recommended) | Pi | Claude Code |
| --- | --- | --- | --- |
| Open source | Yes | Yes | No |
| What it is | The open-source AI Operating System | A minimal agent harness | Anthropic's coding agent |
| Where it runs | Kortix Cloud, your VPC, or on-prem | Your terminal, on the machine that launched it | Terminal, VS Code and JetBrains, browser, mobile, desktop |
| Which models | Any provider with your keys; managed DeepSeek and GLM on credits | Anthropic, OpenAI, Google, Bedrock, Mistral, Groq and more | Anthropic's Claude models |
| How permissions work | Per-tool allow, ask or deny; the most specific rule wins | No built-in permission system | Asks before changing files or running commands |
| How work lands | Branch per session, change request a person merges | Edits the project directory you started it in | Writes code, runs tests, opens pull requests |
| How you extend it | Skills, pi packages, connectors and MCP | Extensions, skills, prompt templates and themes | Command-line tools and MCP servers |
| What it costs | Free is $0 with 500 credits per month; paid from $50 | Free harness; you pay the model provider and the machine | Pro, Max, Team or Enterprise plan, or Console account |

Kortix plan lines from kortix.com/pricing. Pi facts from pi.dev and github.com/earendil-works/pi. Claude Code facts from claude.com, all checked 28 October 2026.

## 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](https://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](https://github.com/earendil-works/pi) 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](https://claude.com/product/claude-code), 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](/pi-harness) 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](/run-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:

```yaml
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](https://kortix.com/docs/project/agents) 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](https://kortix.com/docs/work/sessions) 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.

## Four questions buyers keep asking

### Is pi agent better than Claude Code?

For a team, the runtime is the decision, and Kortix supplies it. Pi is a smaller harness you can point at any provider and extend; Claude Code is Anthropic's client for Claude models with permission prompts and Code Review. Kortix runs pi on an isolated machine per session, keeps the rules in the repo and sends the diff to a merge a person signs off.

### Can I use Claude Code with pi coding agent?

No. Pi and Claude Code are separate harnesses, each with its own session and tool loop, so installing pi does not put Claude Code inside it. They can share a model: pi reads Anthropic's key from the environment, and /model switches mid-session.

### Where do Pi and Claude Code each run?

Pi runs in your terminal, on the machine that launched it, and stays there unless you add isolation. Claude Code runs in the terminal, in VS Code and JetBrains, in the browser, on mobile and in the desktop app, on macOS, Linux and Windows.

### What does a team add around either harness?

An isolated machine per session, permission rules written once in the repository and a merge a person signs off. Kortix supplies all three and keeps pi as the harness.

## Put the harness inside a runtime that owns the rest.

Kortix runs pi in every new session, keeps the permission rules in the repo, and sends each diff through a review a person signs off.

[Try Kortix](https://kortix.com) · [What a harness is](https://picodingagentguide.com/pi-harness)