Pi coding agent hits 1.0 alongside experimental Pi Durable agent framework

Earendil and the Pi community have shipped Pi 1.0, presenting the coding agent as a settled base for building rather than a moving target. Released alongside it is an experimental package, Pi Durable, a framework aimed at agents that run for long periods, keep working through failures, and can be reshaped as needs change.

According to the Earendil blog post announcing the release, which surfaced on the Hacker News front page on October 1, Pi 1.0 keeps its original scope: a coding agent that lives in a terminal, is driven by one person, and runs on a local or remote machine. If the process dies, the operator looks at what happened and tells it to carry on. Pi Durable addresses a different set of requirements — agents that run on varied infrastructure, accept input from multiple surfaces and multiple people, hold conversations of unbounded length, and recover from failures both inside and outside the process. It does not replace the coding agent; it is a framework for building agentic applications of any kind, sharing code such as pi-ai as well as the parent project's design principles.

A harness, defined

The post frames Pi Durable as a "harness": persistent storage combined with the machinery for running one or many model conversations in parallel, supplying the tools those models call and the environments those tools execute in. A conversation is a recorded transcript between a human and an agent, where the agent is a model plus its settings and tool set. Tools run in an execution environment — a laptop, a remote VM, or an in-memory sandbox — and every unit of work, from a model call to a tool invocation, is treated as a task.

The design keeps the whole thing small enough for an agent itself to read. Earendil puts the source, excluding tests, at roughly 15,000 lines — about 150,000 tokens when fed to a GPT model and around 250,000 with Claude — and notes that builders can usually skip the 3,000 lines that make up the storage backends.

Built to run anywhere JavaScript does

A harness opens over a storage backend, and Pi Durable ships three: memory, SQLite, and JSONL, plus a conformance suite and benchmarks for writing your own on top of something like a key-value store or Postgres. The SQLite and JSONL code avoids Node-specific APIs, so with a small adapter it runs on Bun or inside a Cloudflare Durable Object. One process owns a given storage at a time, and other clients attach to that process.

Memory use stays contained on SQLite: only the working set — active transcripts, live tasks, and pending submissions — is held in memory, while everything else waits on disk until needed. Compaction summarizes older messages before they overflow the model's context window, so transcripts stretching to many thousands of messages remain manageable in memory.

Execution environments follow the same small-interface pattern. A Node environment ships by default, giving tools access to local files and a shell, but custom environments are easy to add — so a harness on one machine can drive tools executing elsewhere, with each conversation pointed at its own working directory.

Checkpoints, recovery, and exactly-once work

Durability comes from checkpointing: each step of a run writes a checkpoint before the next one begins. If the process dies — a laptop going to sleep, a container being redeployed, a machine running out of memory — a new process opens the same storage, finds the unfinished tasks, and resumes each from its last checkpoint. An interrupted model request is sent again, with the partial response left in the transcript flagged as aborted; a cut-off tool call reruns only when that is safe, and otherwise the model is told it was interrupted.

Subagents are not built in, but the post says they take a few lines of code to construct, since a subagent runs as a conversation of its own and inherits the same recovery behavior. Submissions also carry a requestId that makes them exactly-once: a client retrying after a crash receives the original submission's answer rather than triggering the request a second time.

Many conversations, forkable at any point

A single harness runs as many conversations as needed, concurrently, with the same guarantees. A conversation can fork another at any point in its transcript, gaining access to everything the parent recorded before the fork without duplicating it. The post offers a Slack analogy: a channel maps to a conversation, and a thread to a fork of it.

Why it matters

The 1.0 label signals that Pi's core single-user, terminal-based experience is now considered stable, which matters to anyone already building on it. The more interesting move is Pi Durable: it takes Pi's minimalist philosophy — a codebase small enough for the agent itself to comprehend and modify — and applies it to the harder problem of durable, multi-surface, long-running agents. Earendil is explicit that lessons learned while building agentic applications on Pi Durable will flow back into the coding agent as they prove valuable, and the package is framed as experimental, with an open invitation for the community to help refine it. For developers watching the agent-harness space, it is a notable bet that durability and malleability can coexist in a small, inspectable codebase rather than a large platform.