Diop Daily #113 — September 2026

Who Gets to Interrupt the Machine?

An autonomous system is defined as much by the interruptions it accepts as by the tasks it completes. A machine that can work for hours, change software, monitor a production system, or prepare a communication has crossed an important economic threshold: the human is no longer present at every step. The scarce resource becomes the supervision interval, the designed moment when a person is asked to decide whether the machine should continue, pause, change course, or stop.

OpenAI’s News RSS reported on September 14 that Perplexity uses GPT-6 Astra to write communications, change software, and monitor production systems, with people checking in much less frequently than with earlier models. This is a vendor-reported account of one deployment, not independent evidence of general reliability. It still names the market movement clearly. The product is being judged by the work that can proceed between interventions.

A second item in the same feed, published September 11, described Cognition using GPT-6 Astra to help Devin test its own work so engineers can review less code and ship more. Again, the claim belongs to the publisher and should be read narrowly. Its architectural implication is broader: the system is being asked to produce evidence that determines whether a human needs to look at the work at all.

Autonomy is a promise about elapsed time; supervision is the institution’s answer for what may happen during that time.

The human is moving from operator to exception authority

Many discussions of agentic software still imagine a human operator who watches a stream of actions and approves each one. That arrangement can be useful during testing, but it does not describe a system intended to handle a meaningful volume of work. If a person must inspect every intermediate step, the machine has accelerated production without changing the labor model around it.

The alternative is exception-based supervision. The agent proceeds within a declared boundary and calls a person when a condition changes the risk, authority, or meaning of the task. A production monitor may escalate a persistent error rather than every normal metric. A software agent may request review when a proposed change touches an untested interface. A research assistant may pause when the evidence conflicts, the source is outside its authority, or the conclusion would affect a public decision.

This arrangement creates a new design obligation. The system must decide which events deserve scarce human attention, explain why they were routed, and preserve enough context for the person to make a decision without reconstructing the entire task. A notification that says “agent needs help” is an interruption without an institution behind it. A proper exception packet contains the state, the attempted action, the evidence, the policy boundary, the possible next moves, and the cost of waiting.

Attention is a budget with a clock

Human oversight is often described as a safety feature, as if its presence were sufficient. Its capacity is finite and its timing matters. A public-service officer may have ten minutes to resolve a case. A site-reliability engineer may need to decide whether an incident is spreading. A scientist may review a result before a laboratory allocates another day of instrument time. The same alert can be harmless at one moment and consequential at another.

A supervision system therefore needs a ledger for attention. It should record:

  • Urgency: how quickly a person must respond before the available options narrow or the external effect becomes difficult to reverse.
  • Decision value: whether human judgment can materially change the outcome rather than merely acknowledge what already happened.
  • Context cost: how much information the reviewer must absorb before the exception is intelligible.
  • Authority: which role may approve, reject, delegate, or quarantine the next action.
  • Outcome: what the person decided, what the machine did afterward, and whether the route should change for future cases.

The ledger makes supervision measurable. It can show that one team receives thousands of low-value alerts while another receives exceptions without enough context to act. It can reveal that a model appears autonomous because people have silently absorbed the recovery work. It can also show where a small improvement in evidence packaging would return hours of specialist attention each week.

Interruption requires a packet, not a ping

Google’s public description of ADK Go 2.0 presents graph-based workflows with human-in-the-loop orchestration, dynamic routing, retries, and built-in resilience. Its A2A material describes secure handoffs between agents and a shared language for collaboration. These runtime primitives make it possible to move work through a graph, yet they do not decide which interruption deserves a person’s time. That is an institutional and product decision at the edge of execution.

An exception packet should be treated as a first-class work object. It can carry:

  1. Situation: the task identity, current state, owner, deadline, and external systems involved.
  2. Trigger: the exact observation or rule that caused the escalation, with the time and version that produced it.
  3. Evidence: relevant inputs, tool results, tests, source records, and uncertainty, bounded so the reviewer can distinguish fact from inference.
  4. Choices: the actions available, their consequences, and the action the agent recommends with its reasons.
  5. Disposition: the human decision, the identity of the decision-maker, the next owner, and the correction to the routing policy if the case teaches one.

This packet changes the economics of review. The reviewer no longer acts as a second operator who follows the machine’s entire trail. The reviewer becomes an authority who receives a bounded decision surface. The machine carries the burden of collection and explanation; the person retains the right to determine whether the next boundary may be crossed.

Reliability is measured by the quality of interruption

A system that checks in less frequently has created more time between actions. That time can produce leverage, or it can hide accumulated error. The relevant question is whether the machine recognizes the situations that require a person and presents them early enough for a meaningful response.

NIST’s AI Risk Management Framework gives this problem a useful discipline through Govern, Map, Measure, and Manage. Govern assigns the accountable role for each class of exception. Map identifies the data, people, systems, and obligations touched by the autonomous interval. Measure records missed escalations, unnecessary interruptions, response time, reviewer context load, and outcomes after intervention. Manage changes thresholds, routing, permissions, or the workflow itself when the evidence shows that the boundary is wrong.

The resulting metrics are more revealing than a simple approval rate:

  • the percentage of consequential exceptions surfaced before an external effect;
  • the median time from trigger to an actionable packet;
  • the proportion of packets resolved without reopening the entire task history;
  • the false-interruption rate for events that needed no human judgment;
  • the share of decisions whose routing policy was updated after review.

These measures test whether autonomy is transferring judgment or merely transferring workload into an invisible queue. They also expose a difference between a reliable agent and a quiet agent. Silence can mean that the system is working within its authority. It can also mean that the escalation path is broken.

The African institution must own the interruption rule

For African institutions, the question of who may interrupt a machine is inseparable from the question of who has authority over the institution. An imported agent can run quickly inside a local workflow while foreign defaults decide what counts as unusual, urgent, credible, or worthy of escalation. The system may speak the local language and still misunderstand the local hierarchy of consequences.

A clinic, cooperative, archive, university, newsroom, or public office has its own thresholds. A delayed payment may be routine in one setting and a serious threat to a household in another. A translation ambiguity may be a minor inconvenience in a marketing workflow and a legal problem in a land record. A production error may be recoverable for a large platform while exhausting the only technical specialist available to a small institution.

Sovereignty therefore requires more than local hosting or access to a foreign model. It requires control over the vocabulary of exception, the roles that receive it, the evidence attached to it, the clock that governs response, and the record of what the institution learned. Local-language support matters because the reason for escalation must survive translation. Local authority matters because a machine cannot infer legitimacy from technical access. Local storage matters because an institution must retain the history of its own judgments.

Where the investable surface is widening

If agents are trusted to work through longer intervals, capital should examine the infrastructure that allocates human attention without erasing human authority:

  • Exception routers: systems that classify events by urgency, authority, reversibility, and required expertise before sending them to a person.
  • Decision packets: products that assemble state, evidence, policy, choices, and recommended action into a reviewable object with a durable history.
  • Supervision ledgers: observability tools that measure interruption volume, context cost, missed escalations, response time, and post-review learning.
  • Adaptive autonomy controls: runtimes that narrow or widen an agent’s operating interval as evidence changes, while preserving explicit checkpoints for consequential actions.
  • Local oversight infrastructure: systems that let African institutions define exception vocabularies, role hierarchies, language conditions, retention rules, and exportable decision records.

The underwriting question is concrete: does the product increase the amount of machine work a qualified institution can safely supervise per unit of human attention? Useful evidence includes the rate of consequential failures caught before effect, reviewer minutes per resolved case, packet completeness, policy-change latency, cross-language fidelity, and the percentage of escalations that remain intelligible after a model or provider changes.

This commercial object differs from workflow routing, storage, permissions, insurance, and recourse. Workflow routing decides where a task travels, while storage preserves state. Permission infrastructure decides what an actor may do with a record. Insurance prices residual risk. Recourse preserves a path to challenge after a decision. Supervision infrastructure decides when a person should enter the active interval and gives that person a usable decision surface. Its unit of value is qualified human attention.

Design the interruption before expanding the interval

An institution can test this architecture with one workflow that already consumes expert time:

  1. List the actions an agent may complete without intervention and the conditions that change the authority, risk, or meaning of the task.
  2. Define the roles that may receive each exception and the response window attached to it.
  3. Generate a packet containing the trigger, state, evidence, choices, recommendation, and uncertainty before asking for a decision.
  4. Run the workflow through ordinary and adversarial cases, then measure unnecessary alerts, missed escalations, review time, and downstream corrections.
  5. Export the decision history and let an independent reviewer determine whether the institution could reconstruct who interrupted the machine and why.

Only after this path works should the autonomous interval become longer. A machine earns the right to continue by showing that its exceptions reach the right authority with enough time and evidence to matter. The future of agentic work will be decided inside those quiet hours between check-ins. Whoever owns the interruption rule owns the boundary between machine speed and institutional judgment.

Sources