Interruption, Steering & Handoff
An interrupt is a request and a resume is a re-execution, so the work is idempotency between the last durable write and the stop point — not the stop button.
The stop button is the easy half, and shipping it is where most teams declare the feature done. Underneath it, the two protocols a 2026 agent most likely runs on both tell you plainly that cancellation may be ignored and that resuming re-runs code which already ran. That means a correctly built stop control can still send the same email twice, and the bug surfaces as a user who interrupted a visibly-wrong run and got charged for it anyway.
Step 1Cancellation is advisory, and the specification says so in as many words.
MCP's cancellation utility is a notification — notifications/cancelled naming a request ID — and notifications are fire-and-forget. The specification is explicit that a receiver may ignore one: if the request ID is unknown, if processing already completed, or if the request simply cannot be cancelled. It also states the race directly: because of network latency a cancellation may arrive after processing has finished and potentially after a response has already been sent, and both parties are required to handle that gracefully.
So a stop request has three possible outcomes, and your interface is probably showing one. The work stops. The work finishes anyway and you discard a result that already had its effects. Or the work is at a point where stopping is not offered and the notification is dropped on the floor. The 2026-07-28 revision tightens the server's side of this further — a server may send notifications/cancelled to tear down a subscriptions/listen stream and must not send it for any other purpose — which is worth reading as a direction of travel: cancellation is being narrowed toward a transport signal, not broadened into a control channel.
The design instruction is to stop presenting cancellation as a verb that completes. A stop control should move the run into a stopping state that is visible and distinct from stopped, and the transition to stopped should be driven by the run confirming it, with a timeout that escalates rather than lies. A spinner that turns into a tick mark because the notification was sent is a user interface asserting something the protocol does not.
There is a live correctness bug in this area worth knowing about if you run the Python SDK: issue #3807, open as of November 2026, reports that in-flight requests are keyed on a coerced request ID, so a cancellation naming request 7 can cancel a concurrent request "7". The reporter's point is the general one — any matching rule looser than exact-ID equality can cancel the wrong work — and the TypeScript SDK, which keys on the typed ID, does not show it.
Step 2Resume restarts the step from the top, which is documented and still surprises everyone.
LangGraph's human-in-the-loop primitive is interrupt(), resumed with Command(resume=...), and its own documentation states the semantics clearly: on resume the runtime restarts the node from the beginning, not from the line where interrupt() was called. The docs' own advice follows from it — make anything before the interrupt idempotent, or move side effects after it, or put them in separate nodes.
Read that twice, because it inverts the mental model the word "resume" installs. The interrupt is not a yield that preserves a stack. It is a checkpoint-and-replay, and everything your node did before reaching the interrupt point is in the replayed region. A node that writes a record, calls an API and then asks for approval does the write and the API call again when the human approves.
This is not a theoretical reading of the docs. As of November 2026 the behaviour has a cluster of open issues around its edges: a side effect repeating after a resume from a tool error (#9185); resuming one of two parallel interrupts inside a subgraph re-running a sibling node that had already completed (#9106); a completed node inside a subgraph re-running on resume with its model call repeated (#9276); and under durability="exit", a node that was still running when its sibling failed finishing its work but not having its writes saved, so the resume runs it again (#9397). A separate documentation issue (#7074) argues the docs oversell the other side too, since effects placed after the interrupt can also repeat if the node later fails and is retried.
The transferable lesson is framework-independent. Any durable-execution engine that implements pause by replaying from a checkpoint has this property, because that is what replay means — the discipline in durable state and resumability. Interruption is not a UX feature you build on top of a loop. It is a constraint on how the loop's steps are allowed to be written.
Step 3The unit of design is the span between the last durable write and the stop point.
Put the two previous steps together and the thing you actually have to engineer becomes concrete. Work out, for each step your agent can be interrupted inside, which side effects sit between its last durable checkpoint and the point where a stop can land. Everything in that span runs twice.
A worked example. A six-step support agent: fetch the ticket, look up the account, draft a reply, post the reply, update the CRM field, close the ticket. The user hits stop while step 4 is in flight. If steps 1–3 checkpointed and step 4 is one node that posts the reply and then waits for approval, the replay re-posts the reply — the customer gets two messages, and the second one arrives after the human intervened to prevent exactly that. The fix is not a faster interrupt. It is that post_reply carries an idempotency key derived from the ticket and the draft digest, so the second execution is a no-op that returns the first result.
# the replayed region is the design surface def post_reply_node(state): # everything above interrupt() runs again on resume key = idem_key(state.ticket_id, digest(state.draft)) sent = mail.send(state.draft, idempotency_key=key) # safe to repeat approval = interrupt({"sent": sent.id, "ask": "close ticket?"}) # and everything below can repeat too, if this node is retried return {"approved": approval}
Three rules fall out, and they are cheaper than they look because they only apply to the spans you identified, not to the whole agent:
- Give every external write an idempotency key you generate, derived from content rather than from a counter — idempotency and retries covers the shapes. This is the single change that makes replay semantics safe.
- Put irreversible actions in their own step, alone. A step containing one unsafe call has a replayed region containing one unsafe call, and that is the smallest the problem gets.
- Gate the actions that cannot be made idempotent rather than trying to interrupt them — a refund, a physical dispatch, a message to a third party with no deduplication. The gate belongs before the call, which is approval and confirmation UX, and the honest version of "interruptible" for these is that the window to stop them closes before the call, not during it.
Step 4Pause, steer and abort are three intents, and only one of them is generically safe.
Collapsing them into a single stop button forces the user to over- or under-act. Pause freezes and preserves, intending to resume unchanged. Steer stops, accepts a correction, and resumes with the new constraint and the prior progress intact. Abort stops and discards.
Abort is the one you can implement generically, because discarding state removes the reconciliation problem entirely — you only owe the user an accurate account of which side effects already landed. Pause is harder than it looks: a paused run holds leases, tokens and open transactions that expire on their own schedule, so a pause with no maximum duration becomes an abort at an unpredictable time. Set an explicit pause ceiling and tell the user what it is.
Steer is the highest-value and most-often-missing one, because the user usually does not want to kill the run — they want to nudge it. It is also the one that interacts worst with replay, since a correction changes the inputs to the replayed region: the draft the user edited is not the draft whose digest keyed the idempotent send. Decide deliberately whether a steer invalidates prior side effects or builds on them, and show the user which. The cheap version that avoids all of this: make steering reachable without stopping, as an "also do X / not Y" input applied at the next step boundary. Most corrections do not need a halt, and a correction that never triggered a replay cannot duplicate anything.
Step 5Handback is where the agent reverts the human's fix, and state is the only cure.
Teams design the agent handing a hard case to a human and forget the return trip. A clean handover transfers the goal, the steps taken, the current state and — crucially — why it stopped, so the human is not re-deriving what the agent already knew. A clean handback is harder: the agent must resume from the human's edited state, not from its own pre-handover memory.
That bug has a specific shape and it is the most trust-destroying one in this whole area. The human fixes the record by hand; the agent resumes from a checkpoint taken before the fix; its plan still contains the write that produced the wrong value; it executes that write; the fix is gone. The user watched the system undo their correction and will never hand back again.
All three interactions — interrupt, steer, handoff — reduce to the same primitive: a task state object that survives a change of control and can be read and edited by whoever holds it. If the agent's working state lives only inside an opaque context window, none of them can be correct, because the human cannot see what they are taking over and the agent cannot see what the human changed. Externalise goal, plan, progress, artefacts and open decisions into a structure both parties read and write, make who currently holds control explicit and visible to both, and have the agent's first action on every resume be to re-read that state and diff it against its plan rather than to continue. Where a human edit and a replayed write genuinely collide, the human edit wins and the step is re-planned — and if your side effects already landed in the world rather than in your own store, you are in repairing agent side effects, which is a much worse place to be than a merge conflict.
Step 6When not to offer free-form mid-task steering.
If a step is part-way through an irreversible external action, 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 would have. The same applies to a step whose replayed region contains a write you could not make idempotent: offering a stop there is offering a duplicate.
And one honest limit on the whole feature. A responsive interrupt requires the agent to reach a safe stopping point quickly, which means short steps — but short steps mean more checkpoints, more replay boundaries and more round trips. Interruptibility is bought with latency and tokens, so buy it where the user can actually see a run going wrong: long, visible, multi-step work. For a four-second call, the honest control is undo, not interruption.
Do this before you touch the UI. List every step your agent can be interrupted inside; for each, list the external writes between its last durable checkpoint and the earliest point a stop can land; then put an idempotency key on every one of those writes and move the ones you cannot key into their own gated step. That list is the actual specification of your stop button, and it is also a test you can write: resume a run twice from the same checkpoint and assert the external side effects happened once. Then make the UI tell the truth — stopping is a state, stopped is a confirmation, and the state snapshot on stop should say what already landed so the user chooses steer, take over or abandon from facts rather than from a blank pause.