Pi Durable is a framework built on the minimalist Pi agent that enables the creation of long-lived agents. Such agents operate without constant user involvement and recover from failures. The framework was released in October. It is designed for building custom agentic systems and integrating them into web applications.

What Pi and Pi Durable Are

Pi is an agent written in JavaScript. It is run locally, you give it prompts, and the agent sends requests to an LLM model and returns the responses. This is a classic agent.

Pi Durable adds persistent operation to this model. The agent can be deployed on a server, where it runs around the clock. A single agent can be accessed from several devices: a mobile app, a web app, or a terminal. Sessions are created in parallel, and each session is unique.

According to the author's assessment, Pi is among his three favorite agents. He places Open-Interpreter in first place, but notes that this project was recently hacked, so its position drops to third. The second place goes to an agent whose name is not legible in the source material, and Pi.

Comparison with Temporal and Cadence

Temporal and Uber Cadence allow you to manage persistent workflows that execute step by step. If one step fails, the workflow can be rolled back and restarted from that step.

Pi Durable implements similar durable execution only for its own agent. Temporal supports several languages: Python, Go, TypeScript, and Ruby.

Reliability Mechanisms

State Persistence and Recovery

Every agent step is persistent. Between steps, the state is saved to a lightweight database, which in the example is SQLite. After a page reload or the creation of a new process, execution continues from the point where the failure occurred.

Example sequence: the model requests a tool call, then context compaction takes place, then a failure occurs. In a regular agent, execution would have to start over. In Pi Durable, recovery happens from the last saved step.

Tool Re-execution

The tool itself decides whether to retry:

• read operations marked as replay-safe are re-executed after a failure;
• commands, such as a deployment, are not retried.

The tool determines which commands are safe to replay. This logic is built into the framework.

Exactly-Once and Idempotency

Every request has an identifier. A request that has already been sent is not repeated. This is how exactly-once delivery is achieved.

Persisting User Decisions

The framework stores confirmations and data provided by the user across sessions. If the user has answered "yes, deploy," the agent does not ask for confirmation again. The decision is stored in the agent's memory. The memo function is used for this.

Cancellation of Operations

Cancellation is implemented along an operation tree. When an operation is cancelled, the operations linked to it up the tree are cancelled as well.

Context Compaction and Dialogue Branching

Compaction runs in the background. When a dialogue reaches the limit, the context is compressed, and the conversation continues. Old messages are not deleted but are kept in compressed form within the context. The author draws an analogy with garbage collection in Java.

Dialogues can be branched. From any agent message, a fork is created, and the conversation continues in the new branch.

Architecture and Deployment

Pi Durable is written entirely in TypeScript and runs in any environment with a JavaScript runtime. It can be run in a browser or on a server. To operate, it is necessary to implement memory and storage primitives.

The framework supports versioning:

• when redeployed, old sessions continue to run on the previous version of the agent;
• new sessions start on the new version;
• each workflow stores the version it was started with.

The author notes that the framework's minimalism and the use of a single language, TypeScript, make this version handling possible. Pi Durable contains about 15,000 lines of code. This makes it possible to hand the entire codebase to an agent and task it with extending the functionality.

Practical Example

The author deployed the Pi Durable service and named it Paidura (short for Pi Durable). The deployment was carried out with a single prompt sent to the Claude Opus 3.5 model. The prompt contained:

• the task of building the Paidura service;
• an instruction to deploy it on Cloudflare using the platform's primitives: Durable Objects, SQL, and others;
• a link to the deployment description;
• an instruction to use the DeepSeek model.

The second command was a request to deploy. The author then asked to add basic authentication (basic auth) to restrict access to the agent.

During the demonstration, the author:

• opened a session in the web interface and named it;
• sent the message "hello" and received a response;
• stated that they live in London; the agent confirmed this;
• asked about the weather; the agent called the get_weather function;
• created a fork of the conversation and asked about the best pubs in the current city; the agent did not have a search tool, but it retained the context about London from the previous branch.

According to the interface, the cost of operation was $0.0005. The only paid component was the DeepSeek key. The service ran in the browser on Cloudflare's free tier.

The agent also connected the "get schedule" and "search history" tools. The author asked to send the current weather in five minutes. The agent created a task. Five minutes later the message arrived, even when all tabs were closed. The author also specified that the message should arrive in 30 seconds.

The agent can add its own MCP tools. The author suggests using it to create a tool that returns a list of pubs in London. The agent remembers the added tool.

Limitations

• Pi Durable is an experimental project.
• The framework is implemented in TypeScript.
• Each process uses one storage unit, that is, one session.
• Marking tools and MCP servers as replay-safe is the developer's responsibility. Unmarked tools are not protected from repeated execution.

Conclusions

Pi Durable allows you to deploy a persistent agent with state preservation, failure recovery, multi-client access, and versioning. The framework is suitable for building enterprise agents that can be invoked from messengers, mobile apps, and other clients. The reliability of execution depends on correctly marking tools as replay-safe.