Pi Durable: Proactive, Multi-Client Agents That Never Stop

0:00"This is a big one." Mario and the Pi team just released Pi Durable — a framework that persists your ongoing work, conversations, and application state through failures, through clients, and through change itself. 0:15It ships alongside Pi 1.0, the first stable release of the Pi coding agent, as an experimental package. IndyDevDan's framing: Anthropic and OpenAI are already using durable-agent primitives like this to build multi-client products — "we must own our agents, our agent harness, and now our durable agents."

What Pi Durable is

2:02A durable agent is one that persists across failure, with several added features — not just `/resume` on a crashed session. A durable agent doesn't wait for you to work; it works for you and then waits. 5:29His claim is strong: "in the future, most agents will be proactive, built just like this. The most valuable agent is the one that doesn't need you to ship."

The proactive agent demo

2:16The opening demo is an on-call incident run end-to-end by agents. His "red team" agent interrupts filming to report a production issue it found and fixed. 3:05The chain: Jev (TypeSafe's classifier, which we've covered before) watches a live event stream, detects an incident, and triggers a Pi Durable agent. That agent walks a standard operating procedure — detect, investigate, root-cause analysis, fix, present for review — through explicit tool calls (updating the incident, reading logs, querying previous events). The specific bug: a classic bad null check with a `!` bang operator in a checkout API ("never use a bang; always null-coalesce"). IndyDevDan declines the first deploy, inspects, then approves: "classic issue, deploy to prod." Crucially, thanks to durable state, the deploy is a safe, non-replayable operation — it can only be called once. The whole thing ran on ~1.5¢ of Jev classification.

Compaction & shared state

6:53First core feature: compaction runs in the background. There's a "compaction mark" you can move; once the agent crosses it, Pi forks the session and starts compacting without blocking you. 8:01Second: a persistent, shared application-state object. Every agent session on a device reads and writes one shared JSON blob via read-state/update-state tools. Switch agents in the same session and each sees the exact same state — one shared object for every session on that device. "This means you can debug one issue and work across many, many agents via shared application state."

Durable jobs & tasks

9:48Third: tasks — durable, repeatable jobs with phases. A job can be raw code, or code plus agents (where "real leverage lies"). If anything fails inside a specific phase, you re-run just that phase. He demos a release-check task that pauses on an approval gate. 10:57This is what he calls "human near the loop" — you're not stuck in the terminal babysitting; the workflow runs a sub-agent that asks you a question only when it needs a decision. A second task ("change watch") baselines a folder and loops over it indefinitely; list-job-statuses shows completed / completed / aborted / last-phase, with full restart control.

Multi-client & detached agents

15:20The headline architectural shift: the agent is detached from any single client. In the demo his agents run on an M4 Mac Mini, M6 Mac Mini, M5 MacBook Pro, and exe.dev cloud sandboxes. 17:10He attaches to a cloud sandbox by ID from a fresh terminal, then creates a session in the browser at the same time — "my agents aren't here. They're in the cloud." The model is a three-level hierarchy: device → workspace → agent, and any client (TUI, browser, CLI, curl, mobile, your product) connects to the same detached agent. "This is the norm for the next stage: the average engineer right now sits prompting back and forth in a TUI, but the next leap requires systems that work without you."

Live tool changes & extensions

18:55Because "everything the harness runs — from calling the model to executing a tool — is a task," you can change it mid-execution. He flips the agent to read-only mode while it's running; the agent notices its earlier tool list was wrong and re-lists. You can strip tools away mid-session, live. 20:26Extensions carry over to durable agents: his fix-smartass-opus (system-prompt tweak for verbose load-bearing agents) and Jev damage control, which puts a Jev classifier in front of every bash command. He runs rm -rf and Jev blocks it ("deletion is irreversible"); he turns the safety off and the same command executes — live, without restarting the agent.

Fork, long-running, non-replayable

22:28You can fork an agent at any point — clone the built-up context to explore a different direction, start fresh, or fork with state. 30:00Agents are long-running: close the laptop, kill the process, restart the machine — they resume from the last checkpoint. Multi-player access is also in: co-workers can connect to the same incident agent and review logs or prompt together. And the non-replayable-operation guarantee means a deploy (or any one-shot side effect) can fire exactly once, safely, across restarts.

Human near the loop

25:39Why go durable? He lists five reasons: proactive agents (work starts before you show up), multi-client agents (one API, every interface), multi-player agents (co-workers join), long-running agents (they don't stop), and human near the loop (approve workflows and deploys, stay in control of what ships). He's honest that jumping straight from "in-loop" to "out-of-loop" is hard — durable agents are the bridge. His working definition of agentic engineering (vs. agentic coding) is how much work your agents do without you. His KPI suggestion: how many agents are doing useful work for you at any point in time.

Why "own your agent"

The through-line is ownership. "It's worse enough that we have to rent our intelligence; your business IP — your code, your algorithms — runs through these agents." He's been early on Claude Code and now Pi for the same reason: you want to control the most important technology available to an engineer — the agent — and the best way to do that is with a harness you can control, extend, and fork. He points to upcoming Apple M5 Ultra machines (512GB unified memory) as the path to owning local intelligence too. One honest caveat he states himself: Pi Durable is experimental, and he won't deploy it to production until it hits a stable V1. And a note on incentives — he states he's not sponsored and takes no sponsorships, but he is selling his own products (Tactical Agentic Coding course, an upcoming "Phase 3" product).

Claims checked

Sources & further reading