Every coding agent this year is a feature arms race. Claude Code manages sub-agents, plan mode, and elaborate permission flows. Cursor wraps an entire IDE around the model. The pitch is always the same: more capability, less setup. And then there is Pi, which refuses to play.
Pi does the opposite, and says so directly in its own documentation: no MCP, no sub-agents, no plan mode, no permission popups, no built-in to-do lists, no background bash. Where other tools list features, Pi's README lists what it refuses to build. This month, a hands-on guide on KDnuggets went out and stress-tested that bet, installing Pi from scratch and writing a working TypeScript extension against the live binary. Reading it, I had one reaction: this is the most important argument in agentic coding right now, and almost nobody is having it.
Because here is my thesis: the fight is not about features at all. It is about tokens. And Pi is winning the fight that matters while everyone else counts checkboxes.
The 1,000-Token System Prompt Is the Whole Story
Start with the number that should stop you cold. Reports on comparable coding agents put their default system prompts at 7,000 to 10,000 tokens before you type a single character. That cost is not paid once. It recurs on every API call, every tool invocation, every continuation. You are renting a lecture about how to behave, and the lecturer bills you per word.
Pi's system prompt runs under 1,000 tokens by design. The only things it injects beyond that are your AGENTS.md files, a global one and a project-specific one, both fully visible and editable. No hidden preamble, no injected reasoning traces, no vendor agenda riding along in your context window.
Here is where I think Pi is right in a way its competitors are terrified to admit: invisible injected context is a tax. When a harness injects context you cannot see, it burns tokens you cannot audit and changes behavior between releases without warning. Mario Zechner, the libGDX veteran who built Pi, said exactly this in the candid essay he published in November, before the project hit 70,000 GitHub stars. This month's hands-on test confirmed it from the other direction: nothing in Pi's loop is hidden from you.
The bet underneath all of this is that frontier models have already been trained on agentic tasks at scale. They know what a coding agent is supposed to do. A smaller prompt does not make the model dumber; it gives the model back its context budget for the actual work instead of instructions about how to behave. It is an economic argument that compounds on every turn.
What Pi refuses to ship, and why I think the refusals are the product:
- No MCP in the core. Protocol glue is an extension you add when your workflow needs it, not a default tax on every session.
- No sub-agent orchestration. No theater of delegation. One focused loop, one job at a time, and the log shows exactly what happened.
- No plan mode. Pi does not pretend the model should narrate its intentions before acting. It acts, and you can see the actions.
- No permission popups. The guardrails are yours to build, which means they fit your threat model instead of a vendor's liability spreadsheet.
- No background bash. Every command is visible, synchronous, and cheap to audit when something goes wrong.
The natural objection is that this is less safe, in exactly the same way a car without a backseat driver is less safe. The hands-on test built a real permission gate as a TypeScript extension: a tool-call hook that pattern-matches destructive bash like rm -rf, sudo escalation, and forced git pushes, then pauses and asks you directly in the terminal. Twenty lines of code, loaded into the running binary with a single flag. A model that cannot be trusted with rm -rf without a vendor-mandated guardrail is not a model problem; it is a harness problem, and Pi hands you the fix instead of the lecture.
One more thing from this month's test deserves more attention than it got: Pi stores sessions as trees, not linear logs. The /tree command lets you branch from any earlier point, with every branch preserved in a single session file rather than overwritten. That is a different mental model from the chat-style scroll, and the right one for exploratory work where you want to try two approaches without losing either.
So where do I land? Let me be direct about what Pi gets right:
- The token bet compounds. A sub-1,000-token prompt does not just save money. It keeps every session honest, auditable, and cheap enough to run long exploratory sessions without flinching.
- Refusing features is a product strategy. Bloat is almost always a feature that got added because a roadmap demanded it. Pi's roadmap is a list of noes, and that is why the project has a point of view instead of a feature matrix.
- Extensions are the real product. The four built-in tools, read, write, edit, and bash, are the kernel. The TypeScript extension API is where Pi becomes yours.
And there is one thing Pi gets dangerously right: shipping no guardrails by default forces the honest conversation about trust. The big labs wrap their agents in safety layers that mostly protect the vendor's liability. Pi hands you the responsibility plainly and says, build what you need. That will burn some people. It will also teach more people than any permission popup ever has.
I keep coming back to a single line from this month's test: the most interesting thing about Pi is not any one feature, but that the project treats "what we did not build" as documentation worth writing. Every other agent is racing to do more. Pi is betting that doing less, transparently, wins. After this month, I think the bet is right, and the feature arms race is about to learn that lesson the expensive way.
Comments