I used to think a long-running coding agent needed a better progress bar.
It needs a better interrupt.
That sounds small until you watch a run work in a repository for a while. It reads files you did not point it at. It takes a wrong turn. It finds a second problem hiding behind the first one. Then a human learns something new and needs to change the assignment. At that moment, cancel only begins the interaction.
The old terminal contract is blunt: send a signal, get your prompt back. That is correct for a process. It is too thin for a run that has read a repository, made edits, and is supposed to leave a PR another person can review. “Can I stop it?” has a direct answer. The useful question is, “What survives when I do?”
That is where the interface moves. A coding agent needs three controls: stop, steer, and inspect. Stop prevents a bad trajectory from getting more expensive. Steer preserves the useful work while changing the target. Inspect turns the interrupted run into evidence.
A cancel key is a destructive API
The terminal got interruption right for the job it had. SIGINT is intentionally immediate. In a small measurement I ran for this piece, a trapped local process exited and was reaped in 15.1 ms, 7.1 ms, and 13.9 ms after SIGINT. The process ends on the spot. That is its virtue.
SIGINT handler, slept, then exited; timing starts immediately before kill -INT and ends after wait reaps it. Hover or focus a bar for its exact value. Source: author measurement; POSIX signal semantics.That measurement is deliberately boring. It times a local signal handler and nothing else, which makes the contrast clean. The operating system can end a process in a handful of milliseconds. A person deciding whether to preserve the edits, add a constraint, or turn the investigation into a review usually needs more than a handful of milliseconds.
The first interface gives us the fast part. The second must give us the rest.
The run has already become a record
Claude Code's own documentation now puts background agents, a resume picker, and session management next to ordinary coding workflows. The Codex CLI documentation lists returning to a saved chat, splitting work across subagents, and moving work to Codex cloud among its core features. Both products now treat coding work as something with a lifetime.
This is the useful shift: a run has a starting instruction, a changing working tree, tool calls, a set of decisions, and an ending that can be inspected. Interrupting it should change its state and keep its record.
What should survive an interrupt?
At minimum: the exact revision the run saw, the files it changed, the command output that explains its last action, the constraints it was following, and an explicit terminal state. “Stopped by a human after test failure” is useful. A vanished spinner tells the next person nothing.
The capture below scrolls the live Codex CLI page from its hero down to those feature cards. The product detail will change. The contract should hold: a person must be able to come back to a run and know what it was doing.
codex resume, subagents and codex cloud.Stop, steer, inspect
Stop is a terminal state with a reason. The run should say what it last completed and what remains safe to keep.
Steer is the control that matters when the new information is not an emergency. “Do not touch the migration. Add a test for the edge case you just found.” A good steering mechanism attaches that instruction to the same working context. Starting a fresh agent and re-explaining the repository is a tax on changing your mind.
Inspect is what makes both controls safe. When the run returns a diff, commands, check results, and a record of how it got there, a reviewer can decide whether to continue, reset, or turn the work into a PR. Missing proof is a different result from done, and it deserves its own name.
The first proof comes before the PR
Teams usually notice proof at the end of a run. They want a PR, checks, and a reviewable change. They should. The first proof arrives earlier: the moment a person intervenes and the system can explain what was happening without asking them to reconstruct it from scratch.
That is how a long-running session earns trust: it makes interruption cheap.
The useful agent interface gives a human a clean place to apply judgment while the work is still alive, then leaves enough evidence behind for the next person to understand the decision.
This is how runs work in Rush. A follow-up message starts a new turn in the same sandbox, so the working tree and the session carry over. Cancel is a status change on the run. A run with missing proof ends as needs_review instead of done. The captured trajectory, every message and tool call, can be read back through the API after the run ends.
The cancel key stays. It just stops being the whole product.
Primary sources: POSIX sigaction, Claude Code common workflows, Claude Code, Manage sessions, and OpenAI Codex CLI, first accessed 9 October 2026. The three latency values are author measurements from the command described in the chart caption; they time a local signal handler and say nothing about model or agent latency. Related: An Agent You Can't Find Is an Agent You Don't Have and Every Agent Demo Hides the Same Number.
