# One Coding Agent Spent a Year Mocking MCP. It Just Made MCP a Core Feature. > Source: > Published: 2026-10-01 03:02:33+00:00 The pi.dev homepage used to display a proud declaration: Pi does not support MCP. Not an omission, not a TODO. A statement of philosophy. The creator, Mario Zechner, had dismissed the Model Context Protocol in blog posts and podcasts for over a year. His argument was concrete, not vibes: a popular Playwright MCP server dumped 21 tool definitions and 13,700 tokens into the model's context on every single session, and a CLI tool with a good README costs zero until the agent actually needs it. On September 29, 2026, Pi shipped version 0.99.0. MCP is now a supported core feature. The team published a self-aware announcement titled "You Said No MCP!" and within hours it was sitting at the top of Hacker News with hundreds of points and hundreds of comments arguing about what it means. Here is the thing: it is not a defeat. It might be the most useful signal about where agent tooling is going all year. Pi is a minimal coding agent built on a simple rule: if it is not needed, it is not built. Out of the box, the model gets exactly four tools: read, write, edit, and bash. Everything else, including subagents, plan mode, permission popups, and MCP, is deliberately left out for extensions to add. At launch, the entire system prompt plus tool definitions measured under 1,000 tokens, where competing harnesses carry tens of thousands. The anti-MCP argument was really a token argument. The standard way MCP worked was that every connected server pre-loaded full schema definitions for all of its tools into your context window. Each tool definition costs somewhere between 550 and 1,400 tokens depending on complexity. Connect three servers and your agent can burn a serious chunk of its window before doing any real work. The most cited number came from Perplexity. Their CTO said at a conference in March 2026 that three MCP servers consumed 143,000 of their 200,000-token context window. That is a 72 percent tax before the agent answered its first question. Perplexity dropped MCP internally after that. For a while, the whole industry seemed to be following: the loudest takes of early 2026 declared MCP dead and CLI tools the winner. The Pi team did not cave to pressure. Their announcement laid out specific conditions, and they are worth understanding, because the same conditions apply to almost every agent harness. **MCP itself evolved.** The July 2026 spec revision made stateless operation the primary focus and removed the initialize handshake and session layer that made production deployments painful. The protocol got donated to the Linux Foundation in December 2025, and adoption numbers kept climbing anyway: more than 17,000 public servers, hundreds of millions of monthly SDK downloads, and a large share of enterprise AI teams running MCP-backed agents in production. Arguing against a protocol that your potential users already run in production is a losing position regardless of technical merit. **The cost problem got a real solution.** Pi did not bolt on naive MCP support. It shipped something called Codemode, and this is the part worth studying. **Integration was nearly free for them.** Pi's harness needed a JavaScript sandbox for Codemode anyway. Once that existed, MCP support was a small step rather than a rewrite. As the team put it: the best way to positively influence something is to embrace it. The old pattern: the model sees every tool's full schema up front, picks one, emits a JSON tool call, waits for the result to come back into context, picks the next tool, repeats. Every intermediate result becomes a permanent resident of your context window. The Codemode pattern: the model writes JavaScript instead. That script executes inside a QuickJS sandbox running in Pi's harness, and the sandbox has the MCP tools available to it. The model discovers tools through documentation rather than pre-loaded schema blocks, calls them from code, chains them together, and only the final result comes back into the context. Three concrete wins, and they mirror what happens when any developer writes a script instead of clicking buttons: Cloudflare described this same pattern earlier with their Code Mode work: expose a tiny search-and-execute surface, let the model write code against a typed SDK, run it in a sandbox. Their claim was that you can hand an agent an entire large API for a fixed cost of around 1,000 tokens. One architectural detail deserves attention. Earlier Codemode-style implementations had a composability problem: each MCP server that wanted code execution shipped its own sandbox, and the sandboxes could not call into each other. Pi puts the sandbox in the harness, not the server. One sandbox, all configured MCP tools available inside it, composition across vendors works. On the HN thread the Pi maintainers confirmed this is the design, and some commenters noted that newer frontier models are increasingly trained on exactly this shape of tool use, which matters more than any single implementation. Both readings have support, and honest coverage should hold both. The capitulation reading: every prominent MCP skeptic from 2025 and early 2026 now ships MCP. OpenAI, Google, Microsoft, AWS, Cloudflare, and GitHub are all involved in the governance of the protocol. When even the team whose homepage taunted the protocol folds, the debate is settled by ecosystem gravity, not by which side had the better argument. The HN thread has plenty of this flavor: people noting that the "MCP is dead" takes from March aged terribly within months. The evolution reading: the MCP that Pi adopted is genuinely not the MCP that was criticized. The stateless spec revision, deferred tool loading, structured data returns instead of text dumping, and harness-level sandboxes fix the exact complaints the skeptics raised. The critics did not lose. Their feedback became the roadmap. The most interesting comment position from the HN discussion came from enterprise developers: in corporate environments, MCP has effectively become the security and auth boundary for third-party agents reaching into company data. At that point "just write a CLI tool with a README" is not a serious alternative, no matter how elegant it is for a solo developer's terminal workflow. If you took the March 2026 discourse seriously and ripped MCP out of your stack, this week was awkward. The practical takeaways: Pi spent a year making a technically literate argument against MCP and lost anyway. That is not a story about being wrong. It is a story about the difference between winning an argument and winning an ecosystem. MCP won because it became the default interface between agents and everything else, and defaults do not need to be the best design, just good enough and everywhere. The genuinely good news for developers is that the convergence forced MCP to get better. Token taxes, stateless transport, sandboxed composition: these fixes exist because loud, informed critics refused to let the flaws slide. The right move now is not to pick a side in a settled debate. It is to steal the architecture: deferred tool discovery, code-first orchestration, structured returns. Your context window will thank you. I write about AI engineering and developer tools every week. Subscribe, it is free. Have you kept MCP in your agent stack, or did you rip it out during the "MCP is dead" wave? What pushed you either way?