Skip to content
← Insights
Nov 14, 20264 min read

An agent's Stop button needs a defined stopping point

Cancellation can arrive after an external action succeeds. The interface needs to show the actual job state and the effect recovery can still have.

A workflow control panel with a large stop square, beside a return arrow and a document status card.

Stopping an agent can leave an action already completed on another service. In a publishing workflow, cancelling the remaining generation can coexist with an article that has already gone public.

The interface needs to show the state that actually exists. A Stop button is useful when the user can understand what it prevents now and what recovery remains possible afterward.

Show the state change the user is authorising

A publishing assistant might prepare a draft before asking to publish it. The review should identify the exact version and destination. If the content changes after review, the interface needs to make that change visible before applying the earlier decision to the new text.

Keep the authorisation's scope attached to the job. Permission to prepare a draft leaves publication as a separate state change. Permission to publish a reviewed article can cover the necessary technical steps within that scope, without asking the user to approve each routine request again.

This principle has an established accessibility context. WCAG 2.2's error-prevention criterion addresses specified consequential submissions through reversibility, checking or confirmation. Its explanation explicitly says the intent is not to require a confirmation for every simple save or edit.

The design decision therefore needs to follow the consequence of the operation. A review of an external publication can expose a meaningful decision. A confirmation repeated for every draft autosave adds effort while asking the user to make no new choice.

Explain what cancellation can still prevent

A job may be preparing a draft, waiting for review or applying a publication request. Those states have different stopping points. The interface should derive its status from the job's actual record.

Before the external request is sent, cancellation can prevent that request. After the remote service accepts it, the application may need a separate operation to reverse the change. Closing the stream of generated text cannot retract a remote state change that has already happened.

Show the remaining effect in ordinary language. If the job has stopped before publication, say that the draft remains unpublished. If publication succeeded before cancellation arrived, show the public result with the recovery action the application can actually perform.

Avoid leaving a generic cancelled label on a partially completed job. The user needs to know which operations finished before the stop. That is information the application can obtain from its execution record, with uncertainty kept visible where a response was lost.

Reconcile an unknown result before retrying

A network timeout can occur after a remote service applies a change. Retrying a create operation immediately can produce a duplicate if the application assumes that no response means no action.

HTTP's idempotency rules in RFC 9110 explain why repeating a request requires knowledge of its intended effect. A client should not automatically retry a non-idempotent operation unless it can establish an appropriate basis for doing so.

For the publishing example, keep a stable job identity with the source article. After a timeout, query for the intended result before attempting another creation. If the remote API supports an idempotency mechanism, implement its documented behaviour explicitly. A locally invented request identifier cannot force an unrelated service to deduplicate work.

The interface can show that reconciliation is in progress. Once the service's state is known, update the result. If the check cannot establish whether the operation completed, leave that specific uncertainty visible and provide a route to investigate it.

Recovery needs an honest description

Unpublishing can remove an article from its current public destination. It cannot guarantee deletion of a copy someone already saved. A recovery label should describe the change the application can make on the service it controls.

The same limitation applies to a multi-step job. Restoring a database field may repair the current record while leaving an already-sent notification in someone's inbox. Track those effects separately so recovery does not imply that every external consequence has disappeared.

Microsoft's human-AI interaction guidelines call for efficient dismissal and correction. For an action-taking interface, the corresponding design work is to make those operations available at the point where they can still help.

Keep recovery controls accessible after the initial progress view disappears. A completed job should have a result record the user can revisit. If undo requires a manual process, explain the actual next step instead of displaying a control that cannot perform it.

Test the moments where state becomes ambiguous

A useful test stops the publishing job just before the external request, then checks that no publication occurred. Another test interrupts the connection after the remote service accepts the change. The expected interface state differs between those cases.

Test a repeated user action too. A double click on Publish should not create two independent jobs for the same reviewed version. The backend needs to enforce the job identity even when the interface prevents an ordinary double click.

Inspect the record as a user would after returning later. It should identify the reviewed version and the destination's observed state. Where a recovery operation ran, the result should show what that operation changed.

An agent interface earns control by making these states inspectable. Give Stop a defined effect, then make the result account for the work that had already crossed the external boundary.

AI agentsUXProduct design