The revealing change in Pi is not on its front page. At the inspected August 20 tips, dev carried 260 commits that were not on main, while seven newer main-branch commits had not crossed back. The comparison spans 374 files and reaches from the agent package into the coding agent, session backends, protocol, server, client, and terminal UI. Those counts are only telemetry. The story is the boundary running through them: Pi is rebuilding an agent conversation so a process can disappear without making the session guess what happened.
That is a different ambition from adding a server mode to a terminal agent. The new harness specification calls itself a durable runtime for agent conversations. Its session has an immutable entry tree, typed mutable values and lists, named lanes over shared history, and an append-only usage ledger. Its operation state is supposed to be a complete restart point, not a clue that recovery code must combine with whatever files happen to remain.
The first commit happens before the model call
The sharpest implemented seam is atomic run acceptance. When a prompt is accepted, Pi writes the user entry, immutable operation metadata, the operation's complete starting state, the lane leaf, and the lane's current-operation pointer in one storage transaction. The acceptance path deliberately does not resolve a model, call a provider, run a tool, fire a timer, or start an execution owner. A prompt can therefore exist durably before the process that will execute it does.
That split changes what “the agent received my request” can mean. In the old conversational mental model, receiving and running blur into one in-memory call stack. Here, acceptance is a receipt. Execution is a separate owner that may arrive later, be replaced, or crash. Pi's focused tests check that the acceptance family commits once, that queued next-run messages are placed before the new prompt, and that model lookup never happens on the acceptance boundary.
The design then puts provider and tool effects inside an explicit two-commit sandwich. Before an external effect, durable state records the intent and reserves the identifiers its result would use. Afterward, settlement commits the complete output and next state. The space between those commits is named as uncertain. The spec does not claim exactly-once effects: a crash can leave the system knowing that a tool may have run without knowing whether it finished. A read-only tool can declare itself safe to replay; a destructive tool can decline replay and produce a synthetic interrupted result instead. The useful move is not pretending the uncertainty is gone. It is making the uncertainty a state the runtime can reason about.
A session is becoming a service, not just a transcript
The same branch is building the surfaces needed to come back to that state from somewhere else. Server-scoped session services let a client list, create, attach, and detach sessions without handing raw session authority to the presentation. A later change routes prompting through a typed Chat service. Then remote events and a client TUI make session switching and model selection visible through those service facades.
The trust boundary is notable. A presentation selects a session through a management service; the host binds the session namespace and rejects stale traffic when that binding changes. The client does not put an arbitrary session ID on every business call, and the server does not expose the raw harness, tool registry, hooks, filesystem data, or storage object as generic remote capabilities. That leaves room for a local terminal, a reconnecting client, or another presentation without turning “remote” into “everything serializes across the wire.”
Durability also has to account for the users Pi already has. The new JSONL work can read legacy v3 sessions, including branches, summaries, labels, names, and usage. At the inspected tip, the first write upgrades that old representation atomically. Its tests cover publication failure and zero-usage adjustment instead of treating migration as a file-copy footnote. A new runtime that cannot safely cross yesterday's session boundary would be a reset, not continuity.
The caveat is executable
This is not a release announcement. In the current runtime2 lane, drive, prompt, resume, abort, queues, compaction, navigation, and related convenience methods still throw SliceNotImplemented. The Chat service has real prompt and durable-abort adapters, while its steer, follow-up, next-run, resume, compact, and navigate methods explicitly report that their slices are missing. The public drive stays disabled until the whole reachable execution and recovery graph exists.
The project's direct durable-drive work package is marked implementation-ready, not complete. Earlier packages for bound storage, atomic acceptance, coherent observation, and event publication are marked complete. That distinction is why the branch can contain real storage, migration, RPC, service, and TUI work while still not constitute a replacement agent loop.
Main moved during this reporting too. Armin Ronacher added a development pi wrapper that runs a checkout's latest build with PI_EXPERIMENTAL=1 by default and falls back to the stable executable for --stable or self-update. That is a doorway for maintainers testing the new path. It does not merge the hidden harness work into a released build.
What to watch on dev
The next decisive change is not another interface or diagram. It is the disappearance of those execution guards: a prompt accepted into starting, driven through a real provider and tool boundary, interrupted between intent and settlement, then reopened through the client without duplicating a settled effect. After that comes release documentation that says which server, client, storage, and migration shapes Pi is prepared to support.
Until then, the dev branch already exposes a useful design test for every agent builder: can the system say what work it accepted, what effect it intended, what outcome it settled, and what remains unknowable after the process dies? Pi's new harness is being built around the idea that those are different facts. The interesting part is that it writes the distinction down before it acts.