Today Earendil and the Pi community shipped Pi 1.0. This reflects our belief that after countless hours of hardening, maintenance, and active development, Pi is now a solid foundation on which to build. Pi also continues to evolve. Together with Pi 1.0, we are shipping an experimental new package called Pi Durable. Pi Durable was built specifically for long-running, durable, and malleable agents that can run anywhere.
\nPi the coding agent is built to run on your (remote) machine, inside a terminal, driven by one person. If the process dies, you look at what happened and tell it to continue. That is what Pi 1.0 focuses on and excels at, and that is not changing.
\nAt Earendil, we want to bring this technology to everyone, in whatever form fits their needs best. For that, we need a harness that runs anywhere, can be reached from different surfaces, supports infinitely long conversations, survives catastrophic internal and external failures, and lets multiple humans steer the same agents.
\nPi Durable is that harness. It does not replace the Pi coding agent. It is a framework for building any agentic application, coding agents included. It shares not only code with the Pi coding agent, like pi-ai, but also its principles: minimalism and malleability.
\nA harness is storage plus the machinery needed to run one or more conversations with large language models in parallel. It provides the tools those models call, and the execution environments the tools run in.
\nA conversation is an interaction between you and an agent, recorded as a transcript. The agent is the large language model together with its settings, like the thinking level, and the tools it can call. Tools do their work through an execution environment, which can be your laptop, a remote VM, or an in-memory sandbox. Everything the harness runs, from calling the model to executing a tool, is a task.
\nLike everything in Pi, Pi Durable is built so your agent can understand it. The entire source code, without tests, is about 15,000 lines.
\nWe want agents to run for a long time and to be able to run anywhere, where anywhere currently means anywhere there is a JavaScript runtime.
\nIn Pi Durable, a harness opens over a storage backend. Pi Durable ships memory, SQLite, and JSONL storage, plus a conformance suite and benchmarks for your own backend. The SQLite and JSONL storage code uses no Node APIs, so with a small adapter it runs on Bun or inside a Cloudflare Durable Object. One process owns a storage at a time, and other clients attach to that process.
\nOn SQLite, the harness only keeps the working set in memory: the active transcripts, live tasks, and pending submissions. Everything else stays on disk until it is needed. Active transcripts are naturally bounded by the model's context window, because compaction summarizes older messages before they overflow it.
\nIn Pi Durable, every step of a run is a task that stores a checkpoint before it moves on. If the process dies, a new process opens the same storage, finds the unfinished tasks, and continues each one from its last checkpoint. A model request that was cut off is sent again; the partial answer stays in the transcript, marked as aborted. A tool call that was cut off reruns if it is safe to; otherwise the model is told it was interrupted. A requestId makes a submission exactly-once.
One harness runs as many conversations as you need, concurrently, all with the same guarantees. A conversation starts fresh or forks another one at any point in its transcript, and sees the parent's history up to that point without copying it. Each conversation also stores its own agent: the model, the thinking level, the selected extensions and which of their tools are active, extra instructions, and the working directory in its execution environment.
\nAn extension is a named bundle of system prompt sections, tools, hooks, and tasks. The application installs extensions in a registry. Each conversation selects which extensions and tools it uses, and stores only their names.
\nCompaction is a task like any other, and it runs while the conversation keeps going. When the context gets close to the model's limit, a background compaction summarizes the older messages, and the summary is placed at the next turn boundary. The older messages always stay in storage. reset() can start a new context from a handoff note while keeping history searchable.
Application state lives in documents: typed JSON stored next to the transcript and changed in the same atomic commits, so the state never disagrees with the transcript that produced it. Each document says what a fork starts with: the parent's value at the fork point, its current value, or a fresh one.
\nThe registry can change while conversations run. Installing an extension under a name that is already installed replaces it in one step. Conversations store extension and tool names, never code, so after a restart they pick up whatever the new process installs.
\nEverything a UI needs is committed state, so any number of clients can attach to any conversation, join late, reconnect, and steer a running conversation or queue a follow-up.
\nPi Durable is experimental, and the API might still change. Point your agent at packages/durable in a Pi checkout, or install:
npm install @earendil-works/pi-durable @earendil-works/pi-ai @earendil-works/chordFull detail, code samples, and demos are in the original post.
","headings":[{"level":1,"text":"Pi Durable","id":"pi-durable"},{"level":2,"text":"Why Pi Durable?","id":"why-pi-durable"},{"level":2,"text":"What is a harness?","id":"what-is-a-harness"},{"level":2,"text":"Long runs anywhere","id":"long-runs-anywhere"},{"level":2,"text":"Survives crashes","id":"survives-crashes"},{"level":2,"text":"Many conversations at once","id":"many-conversations-at-once"},{"level":2,"text":"Extensions","id":"extensions"},{"level":2,"text":"Compaction","id":"compaction"},{"level":2,"text":"Durable application state","id":"durable-application-state"},{"level":2,"text":"Malleable and multiplayer","id":"malleable-and-multiplayer"},{"level":2,"text":"Try it","id":"try-it"}]}}