A new entrant quietly reshuffled the AI coding agent conversation this month. On October 1, 2026, a small outfit called Earendil shipped version 1.0.0 of Pi, an open-source terminal coding agent built under the MIT license. The release lands in the middle of the busiest stretch of coding-tool news all year, with Anthropic’s Claude Code, SST’s OpenCode, GitHub Copilot, and OpenAI’s Codex lineup all pushing updates within the same two-week window. For developers trying to track which tool actually deserves a spot in their terminal, October 2026 has become a genuine inflection point.
Don't miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
What Is Pi 1.0, and Why Developers Are Paying Attention
Pi bills itself as a minimal, extensible terminal agent harness rather than a model of its own. It sits on top of whichever large language model a developer points it at, then handles the orchestration: reading files, running commands, calling tools, and managing context across a session. Earendil Works, the small team behind the project, released Pi 1.0 as fully open source under the MIT license, a deliberate contrast to the mostly closed, subscription-gated coding agents that dominate headlines.
The headline change in version 1.0 is a full-screen terminal interface, now enabled by default instead of sitting behind a flag. That single switch matters more than it sounds. Earlier Pi releases leaned on a simpler command-line output style, closer to a scripting tool than an interactive assistant. The new default UI puts Pi in the same visual category as Claude Code and OpenCode, both of which run persistent terminal sessions with live status panes.
What sets this Pi 1.0 coding agent release apart from a routine version bump is the list of architectural additions bundled into one launch: a new tool-calling system called Codemode, built-in Model Context Protocol support, a long-running agent substrate called Pi Durable, and a provider-routing feature called virtual models. Each of those four pieces targets a different pain point that developers using AI coding agents have complained about for most of 2026.
Inside Codemode: How Pi Cuts Token Costs by Roughly 40%
Codemode changes how Pi exposes tools to a model. Instead of listing every available tool directly inside the system prompt, the way most MCP-compatible agents work today, Codemode lets the model write short JavaScript snippets that call tools programmatically. The model requests a capability through code rather than reading a long menu of tool descriptions before every single turn.
The practical payoff shows up in prompt size. Earendil’s release materials describe prompts shrinking by about 40 percent once Codemode replaces a conventional tool-description block. One cited example tracked a GPT-5.6 coding request that fell from roughly 5,300 tokens down to about 3,300 tokens after switching over. For teams running thousands of agent sessions a day, that kind of reduction compounds fast across a monthly API bill.
| Metric | Before Codemode | After Codemode (Pi 1.0) |
|---|---|---|
| Prompt tokens (cited GPT-5.6 example) | About 5,300 tokens | About 3,300 tokens |
| Tool exposure method | Every tool described directly in the prompt | Model writes JavaScript to call tools on demand |
| Tool loading | All tools loaded upfront, every turn | Deferred loading, tools load only when needed |
| Model routing | One model per session | Virtual models can combine several models into one |
| Long session handling | Not a dedicated focus | Pi Durable adds a restartable, long-running substrate |
Deferred tool loading works alongside Codemode to reinforce the same goal. Rather than loading a developer’s full toolkit into context at session start, Pi 1.0 waits until a specific tool is actually invoked. That change alone trims the baseline context footprint for anyone running a large collection of custom MCP servers, which has become common as teams wire coding agents into internal build systems, ticket trackers, and deployment pipelines.
MCP Finally Arrives, Reversing Pi’s Earlier Position
The Model Context Protocol has become the closest thing the AI coding agent world has to a shared standard, letting a single agent connect to databases, browsers, search tools, and internal company systems through a common interface. Earendil’s own earlier public stance had been that Pi did not need native MCP support, since developers could wire up similar functionality through the project’s extension system. Pi 1.0 reverses that position outright, folding MCP support directly into Codemode.
That about-face says something about where the market has settled. A tool can hold out against a standard for a while, but once enough servers, enterprise integrations, and competing agents adopt MCP as the default wire format, staying outside it starts to cost adoption rather than preserve design purity. Anthropic’s own Claude Code 2.1.296 release, which shipped October 9, already treats MCP connectivity as table stakes rather than a differentiator, and GitHub’s Copilot CLI has leaned the same direction with its own recent tool-use expansion.
Pi Durable Takes Aim at Long-Running Agent Workloads
The second major addition, Pi Durable, is pitched as an experimental substrate for building agent applications that run for hours or days rather than minutes. Earendil packaged it as a separate module, deliberately kept apart from Pi’s core terminal interface so the main tool stays lightweight for everyday coding sessions.
Long-running, restartable agents solve a problem that has dogged the category since autonomous coding agents first appeared: a crashed process, a dropped network connection, or a laptop that goes to sleep can wipe out hours of agent progress on a complex refactor. A durable substrate that can checkpoint and resume state addresses exactly that failure mode. It is still labeled experimental, so production teams should expect rough edges rather than a polished feature.
Virtual Models and 15-Plus-Provider Routing
Pi 1.0 also introduces virtual models, an extension that lets a developer combine multiple underlying models and present them to the agent loop as a single logical model. Someone might route reasoning-heavy steps to one provider and fast, cheap completions to another, all without changing how the rest of the session behaves.
Provider breadth is where Pi 1.0 separates itself most clearly from narrower competitors. Reports describe support for more than 15 providers, including Anthropic, OpenAI, Google, Amazon Bedrock, Mistral, xAI, Hugging Face, OpenRouter, and Ollama, plus the ability to switch models mid-conversation. Pi can also connect to local inference setups through Ollama’s OpenAI-compatible endpoint or the llama.cpp router, an option developers already exploring self-hosted models have asked for repeatedly, as covered in our guide to running Ollama locally.
Codemode’s reach extends past text generation, too. The system can call image-generation models through a models.generateImages() function, with usage billed back to the active session rather than requiring a separate integration. A simplified illustration of that call pattern looks like this:
// Inside a Codemode script, the model can invoke
// a tool or another model directly as code:
const result = await tools.readFile("src/app.ts");
const diagram = await models.generateImages({
prompt: "architecture diagram of the auth flow",
});
// Pi handles billing and context for both calls
// within the same session.Pricing and Availability: What It Costs to Run Pi 1.0
Because Pi is MIT-licensed and provider-agnostic, there is no fixed subscription fee for the tool itself. Reports describe one-line install scripts for macOS and Linux along with a PowerShell installer for Windows, consistent with how most open-source terminal agents distribute today. The actual running cost depends entirely on which model provider a developer points Pi at, whether that is a metered API from Anthropic or OpenAI, a cheaper third-party router through OpenRouter, or a fully local model running on a developer’s own hardware through Ollama at effectively no marginal token cost.
That pricing structure is itself a statement. Proprietary agents increasingly bundle their orchestration layer with a specific model subscription, which locks a team into one vendor’s pricing roadmap. Pi’s open, bring-your-own-provider model pushes the cost conversation entirely onto the token price of whichever underlying model a team picks, a dynamic that becomes more important as token prices themselves start moving.
The Rest of October’s Coding-Agent Wave
Pi 1.0 did not launch into a quiet market. Anthropic shipped Claude Code 2.1.296 on October 9, adding the ability to pin individual workflow agents to a single model and giving subagents their own independent compaction schedules, changes that mostly target teams running large, multi-agent build pipelines rather than solo developers. SST’s OpenCode pushed v1.19.0 and then v2.0.28 across October 11 through 13, introducing an /update command and an opencode upgrade –major path for users moving onto OpenCode 2, alongside a batch of PTY-related stability fixes.
GitHub’s Copilot changelog for October 13 confirmed general availability of Google’s Gemini 4 Argon model inside Copilot, aimed specifically at complex coding, agentic, and reasoning tasks, a move we broke down in our coverage of Copilot CLI’s computer-use expansion. On the OpenAI side, an October research update introduced GPT-6.1 Sol, positioned for coding, computer use, and professional work at roughly one-fifth the standard token price of GPT-6.1 Astra, a pricing shift we examined in our GPT-6.1 Sol versus Gemini 4 Argon comparison.
Comparing Pi 1.0 to Claude Code, OpenCode and Copilot
Laid side by side, the five releases from this single two-week window show just how differently each vendor is approaching the same basic problem of running an AI agent against a codebase.
| Tool | Maker | License | Provider Support | October 2026 Headline Feature |
|---|---|---|---|---|
| Pi 1.0 | Earendil | MIT, open source | 15+ providers including Anthropic, OpenAI, Google, Bedrock, Mistral, xAI, Hugging Face, OpenRouter, Ollama | Codemode cuts prompt tokens by about 40% |
| Claude Code 2.1.296 | Anthropic | Proprietary | Anthropic models, with per-agent pinning | Subagents gain independent compaction schedules |
| OpenCode v2.0.28 | SST | Open source | Multi-provider | New /update command and major-version upgrade path to OpenCode 2 |
| GitHub Copilot | GitHub / Microsoft, model from Google | Proprietary, subscription | Now includes Gemini 4 Argon as a selectable model | Gemini 4 Argon reaches general availability for agentic coding |
| GPT-6.1 Sol | OpenAI | Proprietary, API-metered | OpenAI models | Priced at roughly one-fifth of GPT-6.1 Astra’s token rate |
The split is clear once it is laid out this way. Earendil and SST are competing on openness and provider flexibility. Anthropic, GitHub, and OpenAI are competing on raw model capability and on folding more of the agent loop into their own subscription products. Developers deciding between them are really choosing between two different bets: openness and control, or polish and tight model integration. Our recent look at how Claude Code, Codex, and Copilot split developer usage found the proprietary tier still commands the bulk of daily active use, but open alternatives like Pi and OpenCode are the tools engineers reach for first when they need to plug in a model their employer hasn’t approved a budget line for yet.
Why Token Economics Became the New Battleground
Every one of this month’s releases touches token cost in some way, and that is not a coincidence. Agentic coding tools burn through context differently than a chat interface does. A single multi-step coding task can spawn dozens of tool calls, each one adding its own description, result, and follow-up reasoning back into the running context window. Left unmanaged, that pattern turns an afternoon of agent-assisted refactoring into a surprisingly large bill.
Pi’s Codemode and deferred tool loading attack that cost from the orchestration side, shrinking what gets sent to the model in the first place. OpenAI’s GPT-6.1 Sol attacks it from the pricing side, cutting the per-token rate itself. Both approaches point at the same underlying truth: as coding agents move from occasional autocomplete helpers to always-on collaborators running for hours at a stretch, the token bill, not the subscription fee, becomes the real cost center for engineering teams.
Market Impact for Developer Teams and Engineering Budgets
For engineering leaders, this cluster of releases changes the calculus around which agent to standardize on. A provider-agnostic, open-source harness like Pi lets a platform team swap in whichever model offers the best price-to-performance ratio that quarter, without re-architecting internal tooling built around a specific vendor’s CLI. That flexibility matters more as model pricing keeps shifting, evidenced by OpenAI cutting GPT-6.1 Sol to roughly a fifth of Astra’s rate within the same release cycle.
At the same time, proprietary tools are not standing still on value. Anthropic’s per-agent model pinning in Claude Code 2.1.296 gives teams running multi-agent build pipelines finer-grained cost control, letting cheaper models handle routine steps while reserving a stronger model for the parts of a task that actually need it. Our analysis of how AI coding agents are adding more code without necessarily shipping more software found that raw output volume isn’t the bottleneck teams should optimize for. Context management, tool-call efficiency, and model routing, the exact areas this month’s releases target, are where the real productivity gains or losses show up.
From Autocomplete to Autonomous Agents: Historical Context
The category has moved fast. Three years ago, the dominant AI coding product was inline autocomplete, a tool that finished a line or a function and stopped. GitHub Copilot’s original 2021 launch set that template, and most competitors followed it for years. The shift toward agentic behavior, tools that can read an entire codebase, plan a multi-file change, run tests, and iterate on failures without constant hand-holding, only became mainstream through 2025 and 2026.
MCP’s rise fits the same arc. Anthropic introduced the protocol as a way to standardize how models connect to external tools and data sources, and it spent its first year as a promising but optional add-on. Pi’s reversal on native MCP support, after previously arguing it was unnecessary, marks a useful marker for when a once-optional standard crosses into mandatory territory. When even a deliberately minimalist, opinionated tool like Pi folds in support, it is a signal the protocol war is effectively over.
Open Source vs Proprietary: The Competitive Landscape
Pi and OpenCode sit on the open side of the ledger, both free to inspect, fork, and self-host. JetBrains has taken a related but distinct approach with its own coding-focused model, detailed in our coverage of Mellum 2.1, which targets coding agents with a smaller, more specialized architecture rather than a general-purpose frontier model. That diversity of strategy, open harness, open model, closed harness, closed model, and every combination in between, is itself a sign of a market still working out which layer of the stack actually deserves to be a moat.
Proprietary players retain clear advantages in polish, support, and tight integration with their own flagship models. Anthropic can tune Claude Code specifically around Claude’s strengths in a way no third-party harness can match. GitHub can bundle Copilot directly into the workflow hundreds of millions of developers already use every day. But Pi’s bet is that orchestration itself, the part that decides how tools get called and how context gets managed, is valuable enough on its own that developers will choose an open, swappable layer over a vendor-locked one, even if it means giving up some of that native polish.
What Comes Next: Five Predictions for AI Coding Agents
- Token-efficiency techniques like Codemode will spread to other agent harnesses within two to three release cycles, since the cost savings are too large for competitors to ignore.
- More coding agents will add durable, restartable session support, following Pi Durable’s lead, as teams push agents toward longer autonomous runs.
- Expect further token-price cuts from major model providers before the end of 2026, continuing the pattern set by GPT-6.1 Sol’s discount against Astra.
- Open-source harnesses such as Pi and OpenCode will keep gaining ground inside large engineering organizations specifically because they let platform teams swap providers without rewriting internal tooling.
- MCP will keep consolidating as the default tool-connection standard, and any remaining holdout agents will likely add native support within the next year.
None of these are guaranteed, and the category has surprised forecasters before. But the pattern across this single October release wave, cheaper tokens, open tooling, standardized protocols, and longer-running autonomy, points in one consistent direction rather than several competing ones.
Frequently Asked Questions
What is Pi 1.0?
Pi 1.0 is an open-source, MIT-licensed terminal coding agent harness released by Earendil on October 1, 2026. It connects to more than 15 model providers rather than shipping its own model.
Is Pi 1.0 free to use?
The Pi software itself is free and open source. Costs come from whichever model provider a developer connects it to, ranging from metered commercial APIs to free local models run through Ollama.
What is Codemode in Pi 1.0?
Codemode is Pi’s system for letting a model write JavaScript to call tools programmatically, instead of listing every tool directly in the prompt. Earendil’s release materials describe it cutting prompt tokens by roughly 40 percent.
Does Pi 1.0 support the Model Context Protocol?
Yes. Pi 1.0 added built-in MCP support through Codemode, a reversal of the project’s earlier stance that native MCP support was unnecessary.
How does Pi 1.0 compare to Claude Code or OpenCode?
Pi is open source and provider-agnostic, while Claude Code is a proprietary tool built specifically around Anthropic’s models. OpenCode is also open source but took a different path this month, focused on a major-version upgrade rather than new orchestration features.
What is Pi Durable?
Pi Durable is an experimental, separately packaged substrate for building long-running, restartable agent applications, kept apart from Pi’s core terminal interface to keep the main tool lightweight.
Can Pi 1.0 run local AI models?
Yes. Pi can connect to local inference setups including Ollama’s OpenAI-compatible endpoint and the llama.cpp router, in addition to hosted providers like Anthropic, OpenAI, and Google.
Why did so many coding agents update in October 2026?
Claude Code, OpenCode, GitHub Copilot, GPT-6.1 Sol, and Pi 1.0 all shipped major updates within roughly two weeks of each other, reflecting intense competition around token costs, protocol support, and agent capability as the category matures.
Related Coverage
- VS Code 1.141 Copilot Agent Sandbox Setup: 13 Steps [2026]
- GPT-5.5 Retires From ChatGPT, Codex as Sol Steps In [2026]
- Lake City Bank Opens $12M Innovation Tech Center [2026]
- Foreign Startups Chase Korea's $1.4B Chip Boom [2026]
- Musk's Micron Memory Remarks Spread Across 6 Outlets [2026]
