Pi Coding Agent Gets Subagents and MCP Through Two Extensions
A new walkthrough shows how the minimal Pi coding agent gains parallel subagents and MCP support, plus what the numbers reveal about context and cost.
Written by AI. Yuki Okonkwo
Photo: AI. Eira Pendragon
Pi ships with read, write, edit, and bash. That's it. The ZazenCodes channel published a video this week arguing that for real work you need two more things the base install doesn't include: parallel subagents and Model Context Protocol (MCP) support, both added via community extensions (youtube.com).
The video is a tutorial, but buried in the demos are numbers and trade-offs that say something larger about where agentic coding tools are heading. Let's dig in.
What Pi Actually Is
Pi is a lightweight agent harness: a thin wrapper around an LLM (from OpenAI, Anthropic, or open source providers) that gives the model tools for working with code. The design philosophy is minimalism. Base Pi doesn't ship subagents or MCP support at all, and the creator of the video frames this as a feature: "PI is easy to extend and many people have extended PI. And so I'm using the work of others today."
That framing tracks with how the tool is being discussed elsewhere. A post on thinhcorner.com calls Pi the writer's favorite agent harness precisely for its restraint, and a recent Ask HN thread asking which plugins people enjoy with Pi suggests an ecosystem forming around small, composable extensions (news.ycombinator.com). The video picks the two most popular examples: a subagents extension with roughly a thousand GitHub stars and an MCP adapter with just over a thousand.
The Subagent Demo, and the Number that Sticks
The first demo explores a source folder with ten parallel subagents. The workflow burned about 300,000 tokens across 300 tool calls in roughly 90 seconds, while the main agent's context sat at around 20,000 to 24,000 tokens, about 10% of the model's window.
That's the whole pitch for subagents in one stat: workers burn the context so the orchestrator doesn't have to. Each explorer reads directories, runs list commands, and digests the nitty-gritty, then returns a summary. The main agent gets the conclusion and keeps room to keep going.
The cost angle is where it gets interesting. The default explore agent ran on Claude Haiku 4.5 through OpenCode while the main agent ran on a pricier GPT model, and the presenter admitted the fallback behavior surprised him: "it falls back to inherit which is actually super bizarre. I did not expect that." He ejected the agent config into personal settings and swapped the explorer to OpenAI's smaller Luna model.
His second lesson: ten agents was too many. "There's some overhead to spinning these up and pulling them back," he said, and four handled the same exploration fine. More parallelism isn't free; every subagent carries orchestration weight.
MCP: The Other Half
The second half installs the Pi MCP adapter (MCP, Model Context Protocol, is a standard way for agents to connect to external tool servers). The demo connects to a hosted server from Floot, the video's sponsor, which provides tools for building and publishing full-stack apps with Postgres databases, user accounts, scheduled tasks, and email.
The walkthrough covers the practical details other tutorials skip. Configuration can live in a project-level mcp.json or a global file, depending on whether a server should be repo-specific or available everywhere. The Floot server exposed 55 tools, which the extension lets you inspect and toggle individually. Authentication ran through OAuth with a localhost redirect (port 50604 in the demo), a flow the presenter acknowledged is smoother in mainstream tools: "it takes a little bit more engineering" with Pi, which he framed as a plus. "I love when I get some edge."
The demo end-to-end: prompt Pi to build a feedback hub, approve the OAuth connection, watch tool calls like floot_apply_patch do the work, then publish a live app and verify form submissions landed in the database. It's a decent illustration of why MCP matters even as agent skills proliferate. As the presenter put it: "sometimes an MCP server comes along and I just need to connect to it."
His own follow-up complicates the pitch, though. He built a random-number MCP server, used it to decide whether to keep making YouTube videos (it said keep filming), then admitted he prefers using an agent skill for that task because "the MCP server is kind of clunky." So the honest hierarchy he lands on: skills for lightweight local functions, MCP when you need to reach an external service with real infrastructure behind it.
The Tensions Worth Tracking
A few open questions the video doesn't settle.
The extension dependency question. Pi's minimalism means core functionality lives in community packages with four-digit star counts. If tintinweb's subagents repo or the MCP adapter goes unmaintained, your workflow breaks. That's the trade you accept for a lean harness, and the HN thread suggests people are actively choosing it.
The sponsorship question. The MCP demo showcases a sponsor's product, which is disclosed clearly, but it does mean the "sometimes you just need MCP" argument is being demonstrated on a commercial example. The skill-versus-MCP distinction the presenter draws at the end is arguably the more durable takeaway than the Floot walkthrough itself.
The cost math question. Cheaper models for explorers is smart, but nobody in the video tallies the actual dollar cost of 300,000 tokens of exploration versus a single agent doing the same work sequentially. The context savings are clear; the bill is unquantified.
Why This Matters Beyond Pi
The pattern here is bigger than one harness. Subagents for context economy and model tiering, MCP for standardized external connections: these are becoming table stakes across agentic coding tools, and Pi's approach of getting them through opt-in extensions is one point on a spectrum that runs from Claude Code's built-in everything to roll-your-own harnesses.
If the minimal-harness-plus-extensions model keeps winning adherents, expect the interesting competition to shift from harness features to extension quality and the economics of which model runs where in the stack. And if you're experimenting yourself, the four-subagents-versus-ten lesson generalizes: start small, measure the overhead, scale only when the task demands it.
More Like This
How Model Context Protocol Fixes AI's C++ Tool Problem
Microsoft engineer Ben McMorran shows how MCP lets AI agents actually use C++ developer tools—and why the fragmentation problem is bigger than you think.
Claude Code Nested Subagents: Power and Cost Explained
Anthropic's nested subagents let Claude Code spawn agents five levels deep. Here's what that actually means for your workflow—and your token bill.
Oh-My-Pi: A Batteries-Included Coding Agent Reviewed
Oh-My-Pi builds on the minimal Pi harness to deliver a full-featured coding agent with LSP, a real debugger, voice input, and collaboration tools built in.
What AI Town Experiments Actually Teach Us About Agents
Emergence AI's 15-day virtual town experiment revealed wildly different AI behaviors—and the real lesson has nothing to do with which model is "best."
Agentic Engineering: The 5-Pillar Framework for 2026
IndyDevDan's 5-pillar agentic engineering framework is technically sharp—but who actually gets to build these systems, and at what cost to the OSS tools underneath?
AI Coding Agents Have a Context Problem. Here's One Fix.
MCP2CLI tackles AI coding's context bloat by converting MCP servers to bash commands. Does runtime conversion beat previous attempts at solving this?
Prompt Compression: Smarter LLM Input, Lower Costs
Prompt compression cuts LLM token costs without gutting context. Here's how the main techniques work, what they actually trade off, and where to start.
Running the Mythos Coding Model Locally with llama.cpp
The Mythos Enhanced Coding Model can now run locally via llama.cpp and Pi. Here's what that setup actually means for developers and the broader local AI shift.