Disclosure: the author runs Ship Index Grow, a school on shipping AI products, and Superprompt Pro, a product design practice. Both work on the reversal and review patterns described here.
Direct answer: Agent interfaces are designed for starting work. Few are designed for stopping it or taking it back, and a single undo button gives false control.
Most agent interfaces are designed around starting work. Far fewer are designed around stopping it, or taking it back. UX Magazine's August 2026 piece on agentic UX makes the point well: agentic AI breaks the old assumption that a person starts an action and the system responds. The system now acts first, so the interface has to show, explain and interrupt what it is doing.
The article proposes five patterns: show the agent's plan before it acts, disclose which tools it uses, make its memory visible and editable, track multi-step tasks, and give a clear path to recover from failure. It also argues that autonomy should be a visible slider rather than an on/off switch, paired with on-demand explanations and quick correction tools. The authors call undo one of the most important features.
I agree, and I would go one step further. Undo is hard for agents for a specific reason: an agent often acts in several places at once. It sends a message, creates a record and changes a setting in one run. A single undo button that reverses only the last step gives a false sense of control.
Design for reversal in three layers:
Autonomy without reversal asks people to trust the system blindly. Reversal is what makes a higher autonomy setting reasonable.
Three kinds of reversal
Reversal is not one feature. Some actions can be rolled back inside the product: a draft, a configuration, a file in a versioned workspace. Some can be compensated for but not erased: a message was sent, so the best the product can offer is a correction that the user approves. And some cannot be reversed at all: a payment went through, data left the system, a public post went live. An interface that treats all three the same will either over-promise on the third kind or bury the first kind under needless warnings. Designers should label each action by which kind it is before the user confirms it.
Undo needs a scope the user can see
The most common failure of undo is ambiguity about what it covers. If one click reverses the last step but leaves the agent's earlier changes in place, the user cannot know what state they are in. A good undo control names its scope: undo this run, undo the last change, or restore the workspace to a given time. It should also show what will be reverted before it happens. A preview of the rollback is the same pattern as the preview before commit, applied in reverse, and it is cheap to build once the action log exists.
Logs make recovery possible
An action log is the foundation of every recovery feature. Each entry should record what the agent did, which tool it used, what it changed and whether that change has a known reversal. Logs that only record that a task finished are not useful when something goes wrong. Teams also need to decide how long logs are kept and who can read them. A log that users cannot see does not give them control, and a log that exposes sensitive data creates a different risk. Good logs are readable by the person whose authority was used.
Autonomy and reversibility should move together
A practical rule follows. The more autonomy an agent is given, the stronger its reversal guarantees must be. A low-autonomy assistant that only suggests changes can ship with weak undo, because a person applies every change. A high-autonomy agent that acts across several systems needs previews, scoped rollback, a readable log and a clear list of irreversible actions. Product teams should treat that pairing as a launch requirement, not a later improvement. Users who can reverse a mistake are more willing to let the system act, and that willingness is what makes autonomy useful in the first place.
Related reading
- Permission UX is becoming the real AI safety interface.
- The new AI trust loop is not answer → accept. It is answer → inspect → challenge.
Sources
- "Agentic UX: When the Interface Stops Waiting for You" (UX Magazine, August 25, 2026): https://uxmag.com/articles/agentic-ux-when-the-interface-stops-waiting-for-you