Pi Coding Agent Pricing: Is It Really Free to Use?
Pi and Pi Durable are MIT-licensed and free, but model API calls, routing, and classifiers still bill you. Here's the real cost picture.
What is Pi, and is it actually free?
Pi is an open source agent harness: software that manages a conversation with an AI model, hands it tools, runs those tools, and feeds the results back so the model can keep working. The harness itself costs nothing to download or run. What you pay for is everything Pi orchestrates on your behalf: the model API calls, any classifier or image-generation calls routed through its new “code mode” system, and the infrastructure decisions (like cache warming) that Pi makes to keep sessions efficient. In other words, Pi is free the way a car is free when you already own the gas.
TL;DR
- Pi is an agent harness, not a model, so you connect your own API keys and pay the providers directly for every request it sends.
- Code mode changes what you pay for, since the agent now writes small JavaScript programs that call tools and combine results instead of dumping every tool response into the model’s context, which can cut prompt token usage substantially in some setups.
- Specialist models like classifiers and image generators run through code mode, and their usage shows up in session accounting, though missing catalog pricing can mean some entries appear without a listed dollar cost.
- Virtual models (custom routers) let you mix cheap and expensive models in one session, but the actual routing logic is your responsibility to build and tune, and switching physical models mid-session can break prompt cache reuse, adding hidden cost.
- Cache warming only fires when Pi estimates it saves at least a small, fixed amount in avoided cache-miss cost, and the warming requests themselves count against your session total even though they’re hidden from the model’s conversation.
- Pi Durable is a separate, experimental package for long-running agent applications, and it introduces its own storage tradeoffs (memory, SQLite, JSONL) that affect reliability, not just cost.
Remy doesn't build the plumbing. It inherits it.
Other agents wire up auth, databases, models, and integrations from scratch every time you ask them to build something.
Remy ships with all of it from MindStudio — so every cycle goes into the app you actually want.
How does Pi’s pricing model actually work?
Pi doesn’t charge a subscription or license fee. It’s released as open source software, and the project has been explicit that its value comes from customization: you can add skills, extensions, change the interface, and build your own workflows around the agent. None of that costs money on Pi’s side.
The bills come from three places. First, the model provider. Every request Pi sends to GPT, Claude, or whatever model you’ve connected is billed by that provider under their own pricing, measured in tokens. Second, specialist models reached through code mode, such as a classifier model (referred to in Pi’s documentation and demos as “Jev”) or image-generation models. These calls are counted in Pi’s session accounting, but because some of these specialist calls lack published catalog pricing, they can show up in your usage logs without an attached dollar figure, which makes it easy to underestimate real spend if you’re only glancing at the dollar total. Third, infrastructure overhead Pi introduces to make sessions more efficient, like cache warming refreshes. These consume real provider resources and get added to your session totals even though they never appear in the model’s visible conversation.
What is code mode, and does it make Pi cheaper or more expensive?
Code mode is Pi’s answer to a long-standing complaint about MCP (Model Context Protocol) integrations: that they tend to dump large tool descriptions and bulky text results directly into a model’s context window, which is expensive because you’re paying for every token the model has to read, including irrelevant ones.
With code mode, the agent writes a small JavaScript program that calls tools, filters and combines results, and returns only a compact summary. Intermediate data can stay inside the script and never enters the conversation at all. Pi’s team has reported that for a GPT 5.6 request using default tools plus code mode, prompt tokens dropped from roughly 5,300 to about 3,300, a reduction of around 40% in that specific test. That’s a meaningful savings signal, but it’s a single benchmark under a specific configuration. It should not be read as a universal 40% cut to every task’s total cost.
There’s a tradeoff worth knowing: the JavaScript itself runs in a sandbox, but the tools it calls retain their own permissions. A shell tool can still modify files. An external integration can still take a real action. If a script fails partway through, any tool calls that already completed are not automatically rolled back. So while code mode can reduce token spend, it doesn’t reduce the need for careful error handling, and a half-finished script can still leave you with partial side effects to clean up manually.
What do virtual models and routing add to the cost equation?
- ✕a coding agent
- ✕no-code
- ✕vibe coding
- ✕a faster Cursor
The one that tells the coding agents what to build.
Pi 2.0 introduces “virtual models,” which let an extension register a single selectable model that actually functions as a router. Before each request, the router decides which real model should handle it. A common pattern: use a stronger, pricier model for planning, and a cheaper model for routine implementation work, with a classifier deciding when to switch.
This is where Pi’s pricing story gets interesting. Routing can genuinely lower cost, because you’re not paying premium-model rates for every token of a long session. But there are two costs working against that savings. Switching physical models mid-session can break prompt cache reuse, which means you lose the discount that cached tokens would otherwise give you. And running a classifier to decide when to route adds its own latency and its own (sometimes unpriced) usage. The practical takeaway is that a router is only a good deal if the whole job finishes correctly and costs less end to end, not just if the per-token rate looks cheaper on paper. Comparing a custom router against a plain single-model baseline on your actual tasks is the only reliable way to know.
How does cache warming affect what you pay?
Prompt caching is one of the main ways providers like Anthropic let you avoid paying full price for repeated context. The problem is that a long-running tool call can outlast the cache’s lifetime, forcing a full-price cache miss on the next request.
Pi’s cache warming feature issues a refresh to keep an eligible cache alive, but only when it calculates that doing so is worth it, specifically, only when it estimates avoiding a cache miss would save at least 5 cents. That threshold means warming is a cost-optimization decision Pi is making algorithmically on your behalf, not something that runs unconditionally. You can also turn on idle warming between runs, or disable warming entirely. Either way, those warming requests still consume real resources and count toward your session totals, even though they’re kept out of the model’s conversation context. You can inspect pending warming decisions through Pi’s session command, which is worth checking periodically if you’re trying to understand where your spend is actually going.
Is Pi Durable a different cost story?
Pi Durable, announced alongside the main 1.0/2.0 release, is a separate package for building applications around long-running agent conversations rather than one-off terminal sessions. It lets a single harness run multiple conversations concurrently, each with its own model, tools, and working directory, and supports forking conversations and resuming them after a process restart.
Durable doesn’t introduce a new pricing layer by itself, it still runs on whatever models you connect. But it does introduce storage choices (memory, SQLite, or JSONL) that affect reliability rather than dollar cost directly. Memory storage doesn’t survive a restart. The default SQLite setup doesn’t guarantee the newest commits survive a power or host failure. None of that costs extra, but it does mean that if you’re building a product on Pi Durable, you need to factor in engineering time for durability guarantees, and the APIs are still explicitly labeled experimental, so expect breaking changes.
Frequently Asked Questions
Do I need to pay for a Pi license to use it?
Other agents start typing. Remy starts asking.
Scoping, trade-offs, edge cases — the real work. Before a line of code.
No. Pi is distributed under an MIT license, which means the software itself is free to use, modify, and redistribute. There’s no subscription or seat fee from the Pi project.
What am I actually paying for if Pi is free?
You pay the model providers directly for API usage: every prompt and completion token sent through whatever model you connect (GPT, Claude, or others). You may also incur usage from specialist models reached through code mode, like classifiers or image generators, and from infrastructure operations like cache warming refreshes.
Can using code mode lower my API bill?
It can, because code mode keeps intermediate tool results out of the model’s context instead of forcing the model to read every field of every response. Pi’s team reported roughly a 40% reduction in prompt tokens for one GPT 5.6 test case, but actual savings depend heavily on the specific task and tools involved.
Does custom model routing guarantee lower costs?
Not automatically. Routing between a strong model and a cheaper model can reduce spend, but switching models mid-session can break prompt cache reuse, and the classifier used to make routing decisions adds its own latency and usage. You need to test a router against a single-model baseline on real tasks to know if it actually saves money.
Is Pi Durable production-ready?
It’s described as an experimental foundation, not a finished product. Its APIs may change, default SQLite storage doesn’t guarantee commits survive a power failure, and tool replay after an interruption only happens automatically if the tool explicitly declares that replay is safe. Treat it as a building block that still needs careful engineering around durability.
