Pi 1.0 Ships, Plus an "Undying" Framework: Earendil's Agent Base Goes Stable

What happened

On October 1, Earendil shipped two things at once: Pi 1.0, the stable release of its minimalist terminal coding agent, and Pi Durable, an experimental execution framework for long-running agent applications. Both releases hit the Hacker News front page on October 2 — a rare double in agent-tooling land.

Pi 1.0 first. Pi is Earendil's terminal coding agent, self-described as an "agent harness": the loop, the tooling, and the stopping rules around a model. Its personality is minimalism — the team has said publicly that a feature must prove itself in the wild before being admitted, with every addition weighed against the complexity it brings. The 1.0 list is short, and much of it had already landed across 0.x releases over the previous two months. 1.0 is less a feature drop than a stamp: "we're confident enough to call this stable."

The headline change: Codemode with native MCP

The headline is Codemode: native support for MCP plus non-LLM models such as TypeSafe's Jev classifier and image models. The implementation is worth noting: MCP tools and image models sit behind one orchestrated JavaScript sandbox instead of inside the LLM's context window. That turns tool use from "tokens in the conversation" into "orchestrated program steps" — with a concrete payoff: with default tools, a GPT-5.6 request shrinks from roughly 5,300 to roughly 3,300 prompt tokens.

The rest of the list is harness-maturity work: extensions can define virtual models, deferred tool loading, prompt-cache warming for Anthropic models, mid-conversation system messages (transcript-aware prompt and tool changes), a new TUI theme, and fullscreen mode by default. None of them is explosive alone; together they make an agent base you can trust in a production workflow.

Context matters: two days before the release, Earendil reversed its stance on MCP — from refusing the integration to shipping it properly. The logic is consistent: say no until the integration earns its complexity, then do it right. Pi 1.0 is the finished exhibit of that philosophy.

Pi Durable: giving long-running agents a second life

If 1.0 is the stamp, Pi Durable is the ambition. It's a separate experimental package that ports Pi to TypeScript and moves every stateful component out of the process, aiming at agent applications that run for hours and resume from where they died.

The core mechanism is checkpointing: every step — model calls, tool executions — is recorded as a checkpointed task. Crash, network failure, server restart: the agent picks up from the last checkpoint instead of starting over. This isn't a new invention — Temporal and AWS Step Functions have done it in distributed systems for years — but building it specifically as agent-execution substrate is a necessary step as agents move from single-shot answers toward long, autonomous jobs.

Durable's feature list reads like a spec sheet for a "personal agent operating system": portability (runs anywhere with a JS runtime — Node, Bun, Cloudflare — with pluggable storage backends: memory, SQLite, JSONL); concurrency (one harness running multiple parallel, branching conversations without blocking); extensibility (developers bundle system prompts, tools, hooks, and durable tasks into installable "Extensions"); automatic background context compaction; multiplayer (application state lives in documents right next to the conversation transcripts, so multiple users or UIs can watch and steer the same agent simultaneously); and hot-swapping (tool code updates while the agent runs, with the next call picking it up automatically).

Why vibe coders should care

The direct reason first: Pi is MIT-licensed, installs with a one-line curl, and Earendil says hundreds of thousands of people use it weekly. For indie developers who want to own their agent base, it's a light, hackable alternative to Claude Code — a codebase small enough that an agent can read it, which means you can have your agent modify your agent.

One level deeper, Pi Durable points at a real direction: agent reliability engineering is sinking from "prompt tricks" into "execution infrastructure." We used to make agents fail less with better prompts; next, checkpointing, persistent state, and resumable execution become table stakes. Restate's $20M Series A told the same durable-execution story (we covered it on October 5); Pi Durable puts that thinking into an indie developer's toolbox.

Cold water, though: Durable is explicitly experimental — the team calls it a base to evaluate, not production infrastructure. Checkpointing solves "resume after crash," not "don't repeat side effects" — developers still decide which actions are safe to replay and how external systems stay idempotent. Think hard about that before treating it like a production database.

One last thing: Pi's philosophy of restraint is itself worth savoring. In a year when everyone is bolting features onto agents, someone insisting on "prove it before we admit it" is a rarity — that slowness is the scarce good. 1.0 isn't a victory of features; it's a victory of judgment. And judgment is exactly what vibe coders most need to learn from their tools.