When the Agent Acts First
For most of the short history of AI coding assistants, the interaction model has been simple: a developer opens a chat, types a prompt, and waits. The agent responds. The developer reviews, iterates, prompts again. The human is always the initiating party.
That model is now being turned around. The emerging pattern — call it the proactive agent — flips the sequence: the agent detects something worth acting on, does the work autonomously, and then waits for a human to review and approve. The developer shows up to a prepared fix, not a blank prompt.
Pi Durable, an experimental release of the Pi coding agent, is one of the clearest working demonstrations of this shift so far.
What “Durable” Actually Means
Before getting to proactive behaviour, it’s worth being clear about what durability means here — it’s a more specific claim than “reliable”.
A durable agent (a long-running AI process that can survive interruptions and resume from a saved checkpoint) persists its state, conversation history, and work across client disconnects, process crashes, and machine restarts. This is structurally different from a session that can be manually resumed. With Pi Durable, the agent runs detached from any single terminal or browser window; any client can connect to it, inspect its state, and interact with it — the agent is the fixed point, not the client.
That distinction matters for on-call scenarios. If the agent is detecting a production incident at 2 a.m. and the laptop running it goes to sleep, the investigation should not restart from zero.
The Incident Demo
The concrete demo at the centre of the Pi Durable walkthrough makes the pattern legible. A mock e-commerce app produces a live event stream. Jev — a lightweight AI event classifier (a tool that reads logs and labels each event as normal or anomalous) — monitors that stream in real time. When Jev detects a checkout anomaly affecting 100 percent of traffic, it triggers a Pi Durable agent automatically.
The agent then runs a standard operating procedure without a human in the loop: investigate the anomaly, trace the root cause, locate the offending code, prepare a fix, and then stop and wait for approval. The bug found was a null-check error in the checkout API’s loyalty discount logic — a missing null guard that broke every checkout. The agent produced the fix and presented it; a human reviewed and approved it; the deploy ran and traffic normalised.
Cost for the Jev classifier running throughout a roughly one-hour session: around 13 to 16 cents.
The framing that captures what is new here: the agent does not wait for you to work — it works for you, then waits.
Human Near the Loop
One of the more practically useful ideas in Pi Durable is what gets called “human near the loop” — a deliberate middle ground between the human being fully in the loop (approving every step) and fully out of it (trusting the agent to act autonomously end to end).
Tasks in Pi Durable can be structured as phased jobs, where the agent pauses at a designated checkpoint and requires a human sign-off before proceeding to the next phase. In the incident demo, that pause point was before the production deploy. The agent had full autonomy to investigate and prepare; it had no autonomy to deploy without approval. That boundary is explicit in the task design, not an informal understanding.
This is a useful framing for teams nervous about autonomous agents in production. The question worth asking is not “should we trust the agent fully or not at all?” but “where exactly should the agent pause and wait?”
What Holds Up
A few details from Pi Durable are worth noting for practitioners thinking about their own tooling:
Shared state across agents. Each device running Pi Durable has a single persistent JSON state object readable and writable by any agent session on that device. One agent can record its investigation findings and a second agent — say, a separate support session — can read them without re-running the investigation.
Safe non-replayable tool calls. Pi Durable tracks which tool calls have already executed, so a deploy that is retried after a failure does not deploy twice. This is a prerequisite for trusting any agent with irreversible production actions.
Tool switching mid-session. Tools can be added or removed while an agent is running. Switching to read-only mode mid-session is reflected immediately in the agent’s available tool list. That flexibility matters for sandboxed environments where the safe tool set changes depending on what phase of work the agent is in.
Where This Is Going
A useful KPI for agentic engineering teams captures the directional shift: how many agents are doing useful work right now, without being prompted? That framing is a long way from the current default, where most teams measure AI productivity by how quickly developers complete tasks they initiate. The shift is from AI as a faster typewriter to AI as a colleague that monitors, acts, and escalates.
Pi Durable is experimental, and the infrastructure to run proactive agents reliably in production is still being built. But the pattern it demonstrates — detect, act, wait for approval — is not experimental. That sequence is coming, and teams that start designing human-near-the-loop checkpoints now will have a cleaner transition than those that wait until the tooling forces the question.
Text summarized and optimized using Anthropic’s models and reviewed by a human.