Diop Daily #142 — October 2026

The Agent Needs a Life Between Turns

A short conversation can make an agent look complete. A long task reveals whether it has a life. Research, software maintenance, procurement, publishing, and administrative work all contain pauses that exceed a context window: a person must approve a step, a tool returns an uncertain result, a worker disappears, a provider changes, or the institution has to wait for an external event. The system must preserve the work through that interval and resume with the right state.

This is the distinction between a session and an institution. A session remembers what was said. An institutional runtime must know what was intended, what was committed, what effect may have happened, what remains uncertain, who may authorize the next step, and which project state a new worker should inherit. Long-horizon agency therefore depends on durable execution: a runtime that makes continuation a designed property rather than a lucky recovery from a transcript.

An agent becomes dependable when its work can outlive the process that happened to carry it.

The turn is a unit of risk

Temporal’s October 8 account of running the Pi coding agent on its workflow engine gives the problem a useful shape. The experiment places agent turns across a fleet of workers and kills workers while they are operating. A later worker can continue from the shared session and project state without automatically repeating an interrupted tool call. The report describes request identifiers, checkpoints, recorded outcomes, and project snapshots as parts of the recovery design. These are implementation claims from one system, not proof that all agent runtimes now recover safely.

The architectural lesson is broader than the product. A model call is a computation. A tool call can be a consequence. Sending a payment, editing a repository, issuing a notice, changing a record, or publishing a page may alter the world before the agent receives a result. If the worker dies after the external system accepts the request but before the local runtime records the response, a blind retry can duplicate the consequence.

A durable turn should therefore carry a continuity record with at least:

  • Intent: the requested outcome, the principal who asked for it, and the constraints that bound the work.
  • Checkpoint: the exact state from which the next worker may continue, including model, tools, policy, and project versions.
  • Effect status: whether an external action has not started, is known to have completed, failed, or has an unknown outcome.
  • Authority: the approval, delegation, budget, and expiry conditions that remain valid for the next step.
  • Recovery rule: the read-before-retry, compensation, escalation, or human decision required when the outcome cannot be known automatically.

This record turns a crash from an improvisation into a bounded decision. It also preserves a distinction that many demos erase: the agent may understand the task while the runtime remains unable to prove what happened.

Unknown outcomes need their own state

Traditional retry logic often assumes that a failed request did not take effect. External systems make that assumption unsafe. A network timeout can occur after a bank accepted a transfer. A deployment command can lose its connection after the platform created the release. A message service can acknowledge delivery while the local process is still waiting. The correct next action may be a lookup, a reconciliation, a compensation, or a pause. It may not be another invocation.

The runtime needs a vocabulary for this ambiguity. “Unknown” is a useful state because it stops the system from converting missing evidence into permission. It tells the next worker to inspect the external effect, consult a request identifier, compare the ledger, or ask an authorized person. An institution that cannot represent uncertainty will eventually pay for it through duplicate actions, contradictory records, and difficult disputes.

This is where durable execution separates itself from simple task queues. A queue can make work available again. A continuity runtime must know which step was safe to repeat, which side effect requires an idempotency key, which result can be reused, and which decision needs a human. The commercial value sits in the semantics of continuation, not in the number of jobs a dashboard displays.

Handoff is a capability, not a failure mode

Google’s October description of google/adk-recipes includes Horizon, a reference harness for long-horizon agents. The account names cross-session memory, per-user sandboxes, secrets management, guardrails, resumable multi-step tasks, and evaluation rubrics for memory recall, injection resistance, tool selection, and halting. The same repository is organized for developers and coding assistants, with machine-readable manifests and runnable tests. The point is not that a curated recipe becomes production infrastructure by appearing in a repository. The point is that long-lived work requires a bundle of state, boundaries, and tests that a single prompt cannot carry.

Google’s October 13 report on an eleven-hour performance run across a roughly 205,000-line codebase makes the economic pressure visible. The team gave an agent a long-running objective, repository-specific skills, maintainer conventions, benchmarks, and a full test suite. The report says the run produced measurable optimizations, while earlier work that lacked the repository’s conventions introduced changes that reviewers rejected. Long runs create value when the runtime carries the institution’s method into the work and leaves evidence that another operator can review.

Handoff should preserve more than a chat transcript. A new worker needs the project tree, the last accepted checkpoint, pending approvals, evaluation results, unresolved questions, cost budget, and the rules that define an acceptable change. A provider change should preserve the task’s meaning even if the model’s style changes. A human interruption should leave a clean place to return, rather than forcing a second person to reconstruct the entire history from logs.

African institutions need continuation under their own conditions

Durable execution has a direct sovereignty dimension. Institutions across Africa often operate across intermittent connectivity, distributed teams, shared devices, mobile payment rails, changing languages, and uneven access to compute. A workflow that assumes one continuously connected process and one foreign service can make local capacity fragile even when the model itself is capable.

A publisher may need an agent to prepare a multilingual edition across several review sessions. A cooperative may collect field records offline and reconcile them when a connection returns. A public office may pause a case until a human authority is reachable. A laboratory may move a job from an expensive cloud worker to a local machine without losing its evidence. In each case, the institution needs to own the continuation record: the authority, state, language, correction path, and conditions that define legitimate resumption.

NIST’s AI Agent Standards Initiative places authentication, identity infrastructure, open protocols, and security evaluations in one strategic frame. Durable execution adds the time dimension to that frame. The question is not only which agent is acting and what it is allowed to do. It is also which agent is resuming, from which checkpoint, with which evidence, after which interruption. Portability means carrying that answer across workers and providers.

Where the investable surface is widening

The commercial object is the durable execution layer: infrastructure that preserves intent, state, effects, authority, and recovery semantics so long-running agent work can continue without silently repeating its consequences.

  • Durable workflow engines: runtimes that checkpoint agent steps, pause for signals, resume across workers, and keep execution history independent from one process.
  • Effect ledgers: systems that bind external actions to request identifiers, idempotency keys, observed outcomes, and compensation procedures.
  • Handoff fabrics: portable state packages carrying project files, policy versions, approvals, evaluation fixtures, budgets, and unresolved decisions across runtimes.
  • Interruption and approval controls: mechanisms that stop a workflow at a consequential boundary and return it to an authorized human without losing its place.
  • Recovery testing: chaos and replay services that kill workers, delay tools, change providers, corrupt connections, and measure whether the institution can resume safely.

Underwriting can begin with operational measurements: the percentage of steps with explicit checkpoints; the share of external effects carrying idempotency and reconciliation evidence; the time required to resume after worker loss; the rate of duplicate side effects in fault injection; the proportion of workflows that can move between providers; and the number of human approvals that return to the exact decision boundary rather than restarting the entire task.

A durable runtime earns its position by lowering the cost of interruption without hiding the risk of continuation. Its moat is the accumulated knowledge of how institutions pause, reconcile, approve, compensate, and resume. That knowledge is closer to operating infrastructure than to a model feature, and it remains useful when models, clouds, and interface styles change.

Build the life between turns

An institution can test this layer with one workflow that already suffers from expensive interruption: a software release, a research import, a procurement approval, a multilingual publication, or a service case. Define the principal, the desired outcome, the irreversible effects, the approval points, and the external records that can confirm each effect.

  1. Checkpoint before every consequential tool call, including the request identifier and the authority that permits it.
  2. Record the effect as unknown when the runtime loses contact before it can confirm the outcome.
  3. Require the next worker to reconcile the external state before it retries or compensates.
  4. Move the work across a second worker or provider while preserving the project state, policies, fixtures, and pending decisions.
  5. Kill the worker at different points and measure whether the resumed task reaches the same controlled decision without duplicating side effects.

The test should include human interruption, delayed messages, revoked authority, changed dependencies, partial connectivity, and a language variant that changes the interpretation of a request. A workflow that survives only the clean path has demonstrated automation. A workflow that can explain its pause, preserve its uncertainty, and continue under a new operator has demonstrated institutional capacity.

The agentic economy will be described through faster models and broader tool access. Its serious infrastructure will be judged in the quiet interval after a process dies and before the work resumes. The institution that owns that interval owns the difference between an agent that can act and an agent whose work can be carried forward.

Sources