Pi coding agent vs Claude Code: workflow, permissions and total cost

Pi and Claude Code are both terminal coding agents that can be pointed at an endpoint you choose, but they are not the same kind of product. Pi is MIT-licensed software that leaves out most agent scaffolding on purpose; Claude Code is proprietary software built around an enforced permission system and the Anthropic Messages protocol. Those two facts decide the comparison more than any feature list, because one of them is built to run whatever models your endpoint serves, while Anthropic documents the other as unsupported for that.

One disambiguation first, since the name collides. "Pi" here is the coding agent published at pi.dev by Earendil Inc. — not Pi by Inflection AI at pi.ai, not the Pi Network coin, and not Raspberry Pi. Its CLI is @earendil-works/pi-coding-agent, MIT, latest version 0.86.1 published September 20, 2026 on the npm registry, and its repository earendil-works/pi is MIT, not archived, and was last pushed to on September 21, 2026 (GitHub API). Claude Code installs from @anthropic-ai/claude-code, latest version 2.1.278 published September 19, 2026, and its LICENSE.md reads in full: "© Anthropic PBC. All rights reserved. Use is subject to Anthropic's Commercial Terms of Service". Both clients ship frequently, so treat these as the numbers on September 21, 2026 rather than as current; the documentation checks below are dated September 19, 2026.

Which one should you pick

Answer these in order. The first one that gives you a firm answer is the decision.

• Do you need permission rules someone else can rely on? Then Claude Code. Its permissions documentation defines six modes — default (labelled Manual), acceptEdits, plan, auto, dontAsk and bypassPermissions — and states that "Permission rules are enforced by Claude Code, not by the model", with allow, ask and deny rules you can check into version control or set in managed settings. Pi's security page says the opposite in plain terms: "Pi does not include a built-in sandbox", and built-in tools that "read files, write files, edit files, and run shell commands with the permissions of the pi process". Its usage page separately lists permission popups among the things it leaves out.
• Do you need to run models from more than one lab in one client? Then Pi. Its custom-provider schema accepts openai-completions, openai-responses, anthropic-messages and google-generative-ai. Anthropic's gateway page says it "doesn't support routing Claude Code to non-Claude models through any gateway".
• Do you want MCP, subagents, plan mode and to-dos without building them? Then Claude Code. Pi's own feature page states that "It intentionally does not include built-in MCP, sub-agents, permission popups, plan mode, to-dos, or background bash", and points you at extensions, packages, containers and tmux instead.
• Does the agent itself need to be open? Then Pi: MIT on npm and in the repository, forkable, and drivable from another process through --mode rpc. Claude Code's licence reserves all rights.
• Do you need the desktop app, the web surface or Remote Control? Then Claude Code, and not through your own endpoint. Its overview says "Most surfaces require a Claude subscription or Anthropic Console account. The Terminal CLI, VS Code, and JetBrains also support third-party providers", and the desktop tab adds that a paid subscription is required. Remote Control is the separate case: Anthropic's environment-variable reference states that "As of v2.1.196, Remote Control is disabled when this points at a host other than api.anthropic.com".

What none of this decides is which writes better code. No controlled comparison of the two was run for this page, and nothing below should be read as one.

Side by side

Rows read from Pi's quickstart, usage and security pages and from Claude Code's overview, permissions and cost documentation, September 19, 2026.

The execution model is the real difference

Read Pi's omission list as a specification rather than as missing features: the six things it names are the six most buyers assume every agent has. If your workflow depends on an MCP server, a planning step before edits, or a permission prompt you can say no to, Pi asks you to build or install that, not to configure it.

Claude Code sits at the other end. The rules are evaluated by the client, deny takes precedence, and a PreToolUse hook cannot override a deny rule — so they survive whatever the prompt or CLAUDE.md says, which is what makes them useful to an organization rather than to one developer. Pi's nearest concept, project trust, is narrower by its own description: "Project trust is only an input-loading guard. It prevents a repository from silently changing pi's settings or extensions before you approve it. It does not make untrusted code, untrusted prompts, or untrusted model output safe."

Neither posture is wrong, but only one of them answers an audit question. Settle it before comparing prices: configuration cannot close this gap.

Pointing each client at your own endpoint

This is the second structural difference, and it runs the other way. Claude Code takes an environment variable and one protocol family; Pi takes a JSON file and four.

The Claude Code column comes from its environment-variable reference and gateway compatibility guide, checked September 19, 2026. The "turns off" row is worth spelling out, because each item is a feature you lose quietly rather than an error you see. A non-first-party ANTHROPIC_BASE_URL disables MCP tool search by default, re-enabled with ENABLE_TOOL_SEARCH=true if the proxy forwards tool_reference blocks; as of v2.1.196 Remote Control is disabled when that variable points anywhere other than api.anthropic.com; fine-grained tool streaming is off by default; and model discovery is opt-in, with CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY=1 sending GET /v1/models?limit=1000 on a three-second timeout, treating any redirect as failure, and keeping only entries whose id contains claude or anthropic. Two checks bypass the variable entirely and call api.anthropic.com directly — the fast-mode availability check and the WebFetch domain safety check — so a network that blocks that host breaks them even while inference works.

The credential line matters for billing, not just for auth. Anthropic's gateway page is explicit: while a gateway credential is active "the credential replaces the subscription login for that session, and the subscription's usage limits don't apply", and that traffic is billed per token to whoever owns the credential. Setting only the base URL does not do that — a saved claude.ai login stays the active credential and its limits still apply.

# Claude Code: two environment variables, and whatever answers at that
# origin has to speak the Anthropic Messages API.
export ANTHROPIC_BASE_URL=https://api.kunavo.com   # origin only, no /v1
export ANTHROPIC_AUTH_TOKEN=sk-kn-...              # replaces the subscription
export ANTHROPIC_MODEL=claude-sonnet-5

The origin has no /v1: Anthropic-style clients append /v1/messages themselves, so https://api.kunavo.com/v1 produces requests to /v1/v1/messages and a 404. See the base-URL page and the Claude Code setup guide. One more Kunavo-specific consequence: this API serves no /v1/messages/count_tokens route, and Claude Code's compatibility guide says token-counting endpoints are the only optional ones — without it, "Claude Code falls back to a character-based estimate of context usage", so /context shows approximate counts.

Pi's version of the same job is a file, and because it accepts OpenAI-shaped APIs it can take the route Claude Code has no option for:

{
  "providers": {
    "kunavo": {
      "baseUrl": "https://api.kunavo.com/v1",
      "api": "openai-completions",
      "apiKey": "$KUNAVO_API_KEY",
      "models": [
        {
          "id": "claude-sonnet-5",
          "name": "Claude Sonnet 5",
          "cost": {
            "input": 2,
            "output": 10,
            "cacheRead": 0.2,
            "cacheWrite": 2.5
          }
        }
      ]
    }
  }
}

Watch the trailing /v1. An openai-completions provider wants https://api.kunavo.com/v1. For the anthropic-messages shape, Pi's models documentation shows both spellings in its own examples — https://proxy.example.com/v1 under custom headers, and a bare https://proxy.example.com under Anthropic Messages compatibility — so it does not settle the question, and if a first call 404s this is the line to change. Two more Pi-specific traps from the same page: a custom model's cost block defaults to zero across every rate category, so a provider you add reports $0 in the footer, which Pi documents as showing session cost, until you type the rates in; and contextWindow and maxTokens silently default to 128,000 and 16,384, so set both to the window published on the model's page in the catalog. Credential precedence is documented and worth knowing when a stale key wins: the CLI --api-key flag, then auth.json, then an environment variable, then models.json.

Plans and token bills on the same page

Neither client charges for itself, so the whole difference in cost is which layer you buy. Pi has nothing to buy at all: it is MIT-licensed, and pi.dev publishes no plan, tier, seat or hosted service. Claude Code is free to install and then needs access from somewhere.

All Anthropic plan figures quoted from claude.com/pricing on September 19, 2026. Two honest gaps: the Max page publishes no separate price for the 20x tier, so any "$200 for Max 20x" you read elsewhere is not from that page; and the premium-seat figure genuinely differs between the pricing page and the enterprise deployment overview, which shows "Teams: $150/seat (Premium) with PAYG available". Neither is resolved here — check the number checkout actually quotes you. No Anthropic page found in this check publishes hours, messages or token counts for Pro, Max 5x or Max 20x, so no usage figure appears on this page either.

What the tokens cost

Put both clients on the same endpoint and they pay the same rate per token; what differs between them is how much context each re-sends per step, which depends on your repository far more than on the tool and was not measured here.

The table below is illustrative token arithmetic, not a measured task cost and not a bill ceiling. Assume one working day of agent use: 12 turns, each sending 60,000 uncached input tokens and receiving 3,000 output tokens, for 720,000 input and 36,000 output in total, with no cache reads, no cache writes, no images and no tool charges. Kunavo rates are rendered from the live catalog; the vendor column is claude.com/pricing, checked September 19, 2026.

Read the rows rather than the ranking. Claude Sonnet 5 sits at the same number in both columns, so for that model the route is not a price question at all; Claude Opus 5 is where the two columns separate. Scale by your own working days before treating any of it as a budget — and note that this assumes no caching, which is the single largest omission. Anthropic's own cost page states that the prompt-cache lifetime "is an hour on a subscription and drops to five minutes once you're drawing on usage credits; on an API key or cloud provider, it's five minutes by default", so how you pay changes the cache hit rate and therefore the bill. Kunavo cache charges are documented at caching; whether Pi's PI_CACHE_RETENTION=long reaches this endpoint has not been tested.

For a published anchor rather than arithmetic, Anthropic's cost documentation reports that "Across enterprise deployments, the average cost is around $13 per developer per active day and $150-250 per developer per month, with costs remaining below $30 per active day for 90% of users", with background processes typically under $0.04 per session. That is Anthropic's figure for Claude Code on its own billing; no equivalent figure exists for Pi, because nobody publishes one. Kunavo's catalog amount is a billing floor rather than a cap — when the upstream reports its charge, the bill is the greater of catalog cost and upstream cost times the applicable markup, as billing explains — and the minimum top-up is $10 in prepaid credit, a funding minimum rather than a task fee or a subscription.

The subscription question nobody can settle for you

Both clients can be signed in with a Claude plan, and three official sources describe what that does differently. They are quoted here with their dates rather than resolved, because resolving them from outside would be a guess.

Nothing on any Anthropic page names Pi specifically, and the login article's permission is discretionary rather than a guarantee. The one part all three agree on is the direction of travel: an API credential is the route Anthropic prefers for a third-party client, and in Claude Code a gateway credential removes the subscription from the session entirely. Check Settings then Usage in your own account before routing paid work through a plan. Claude plan limits covers the subscription side, and Pi pricing goes further into Pi's four ways to pay.

What moving between them actually costs

Less than the feature lists suggest, in one direction. Repository context transfers unchanged: Pi loads AGENTS.md or CLAUDE.md from the current and parent directories, with ~/.pi/agent/AGENTS.md for global instructions, so a repo already set up for Claude Code needs no edits to be read by Pi. Scripted usage has a counterpart on both sides too — claude -p and pi -p, with Pi adding --mode json and --mode rpc for process integration.

What does not transfer is everything in the execution-model section: permission rules, MCP servers, subagent definitions and plan mode have no built-in Pi counterpart to migrate to — Pi's usage page points at extensions, packages, containers and tmux instead — and the desktop and web surfaces have none at all. Going the other way, a Pi extension has no Claude Code counterpart to install. No hour or day estimate for the switch is offered here, because there is no basis for one — run one bounded, real task on each before moving scheduled work.

If you are shortlisting more broadly, Pi vs OpenCode and OpenCode vs Claude Code cover the two adjacent pairs, and Claude Code alternatives separates the tool question from the billing question first. For the endpoint itself, the Claude Code setup guide is the published configuration reference, and creating a Kunavo account gets you a key to test one task against.

FAQ

Documentation and plan prices checked September 19, 2026 and re-confirmed September 21, 2026: pi.dev's quickstart, usage, models, providers and security pages; code.claude.com's overview, permissions, costs, environment-variable, gateway and gateway-compatibility pages; claude.com/pricing; and two support.claude.com articles. Version numbers, the anthropics/claude-code licence file and the GitHub API for earendil-works/pi were re-fetched September 21, 2026. Kunavo token rates are rendered from the live catalog and every dollar figure here is illustrative token arithmetic, not a measured task cost. Neither client has been runtime-tested against Kunavo, and no quality, speed or benchmark comparison between them was run.