The ability to stop and redirect a running agent is a feature, not an error path.
Long-running agents will sometimes be on the wrong track, and the user will see it before the agent does. If the only controls are "wait for it to finish" and "kill it and lose everything," the user has no real authority — they have a kill switch and a hope. This essay treats interruption, mid-task steering, and clean human takeover/handback as primary interactions: how to stop work without destroying it, inject a correction without a full restart, and pass control across the human/agent boundary in both directions without losing state.
Interruption must be promptly responsive and non-destructive.
Two properties make a stop control real. Responsive: the agent must reach a safe stopping point quickly — not after the current 90-second tool call and the next three planned steps. Non-destructive: stopping must preserve work done so far, not discard it. An interrupt that throws away ten minutes of progress trains users never to interrupt, which means they let a visibly-wrong run continue — the exact behavior the control was meant to prevent.
- Checkpoint at step boundaries so a stop loses at most the current step.
- Make in-flight side effects abortable or, where they cannot be, gate them (H2) so an interrupt never lands mid-irreversible-action.
- Surface a state snapshot on stop — what's done, what's pending — so the user can decide steer / take over / abandon from facts, not a blank pause.
Distinguish pause, steer, and abort — they are three different intents.
Collapsing them into one "stop" button forces the user to over- or under-act. Pause: freeze, preserve everything, intent to resume unchanged. Steer: stop, accept a correction, resume with the new constraint and the prior progress intact. Abort: stop and discard, intent not to continue this attempt. Steering is the highest-value and most-often-missing one — the user usually does not want to kill the run, they want to nudge it.
# Steer = correction folded into preserved state, not a restart ckpt = agent.checkpoint() await agent.interrupt(reason="steer") ckpt.constraints.add(user_correction) await agent.resume(from=ckpt) # keep prior work; apply new constraint
Make steering reachable without stopping the world: an "also, do X / not Y" input the user can submit while the agent runs, applied at the next step boundary. Most corrections do not need a full halt.
Handover and handback are symmetric — design both.
Teams obsess over the agent handing a hard case to a human and forget the return trip. A clean handover transfers context so the human is not re-deriving what the agent already knew: the goal, the steps taken, the state, and crucially why it stopped. A clean handback is harder and more neglected: when the human is done, the agent must resume from the human's edited state — not from its own stale pre-handover memory. The classic bug is the agent overwriting the human's manual fix on resume because it never reconciled state.
State is the substrate of every transfer — make it a shared, inspectable object.
Interruption, steering, and handoff all reduce to the same primitive: a state object that survives a control change and can be read and edited by whoever holds control. If the agent's working state lives only inside an opaque context window, none of these interactions can be correct — the human cannot see what they are taking over, and the agent cannot see what the human changed. Externalize task state (goal, plan, progress, artifacts, open decisions) into a structure both parties read and write. Who currently holds control must be explicit and visible to both — ambiguous control is how two actors edit the same thing and lose a change.
Reconcile on resume; never blindly continue.
After any human intervention, the agent's first action on resume must be to re-read shared state and detect what changed, not to continue from its pre-interrupt plan. The world may have moved: the human edited an artifact, the earlier goal is now partly satisfied, an assumption is now false. Treat resume as "re-orient against current state, then act" — the same conservative-restart discipline a careful human uses when picking up an interrupted task.
An agent that resumes from its own memory instead of reconciled shared state will silently revert the human's intervention. This is the single most trust-destroying handoff bug — the user fixed it, watched the agent undo the fix, and will never hand back again.
When NOT to allow free-form mid-task steering.
If a step is mid-way through an irreversible side effect, the right control is "finish or roll back this step cleanly," not "accept an arbitrary correction now" — steering into an uncommitted external action corrupts state worse than no interruption at all.