Agent UX: designing for review.
An agent that does an hour of work in five minutes is worth nothing if checking it takes fifty. That ratio — review cost over do-it-yourself cost — is the number your interface is really optimising, and most agent UIs quietly make it worse: prose where the reader needed a diff, a finished action where they needed a plan, and a confident summary where they needed to know which parts were guessed.
Review cost is the metric.
Automation pays when the work saved exceeds the work created. An agent creates work: someone has to decide whether to accept the output. If that decision takes as long as doing the task, you have built a demo.
- Length is not the driver — legibility is. A 400-line diff in a familiar format reviews faster than three paragraphs describing what changed. Prose forces the reader to reconstruct the change; the artefact is the change.
- Reversibility sets the required depth. An action you can undo in one click needs a glance. An action that emails a customer needs a read. Spend the review budget where it buys something — this is the same allocation decision as human-in-the-loop, seen from the interface side.
- Batching helps until it hides. Reviewing twenty small changes at once is cheaper per change, right up to the point where the reviewer stops reading and starts scrolling.
The clearest symptom of a badly designed agent surface is a user who reads the summary, cannot tell from it whether the work is correct, and approves anyway. That is not a careless user. That is an interface that made verification more expensive than trust, and got the trust it asked for.
Plan before, artefact after.
The cheapest moment to correct an agent is before any tool has fired. Correcting a plan costs one sentence; correcting a completed run costs a rollback and whatever already left the building.
- Show an editable plan, not a confirmation dialog. "I will do X — proceed?" collects a click. A plan the user can edit collects a correction, and it surfaces the misunderstanding while it is still free.
- After the run, show the artefact. The diff, the rows that changed, the message as it will be sent. Rendered output beats described output every time.
- Group by consequence, not chronology. A timeline of forty tool calls is a log, not a review surface. Sort by blast radius: what was written, what was deleted, what left the system, then everything that only read.
- Progressive disclosure. Summary by default, full trace one click away, always available and never mandatory. See progressive disclosure.
Calibrate trust per claim, not globally.
The goal is not a user who trusts the agent, nor one who distrusts it. It is a user whose confidence tracks the agent's actual reliability on this specific output. That requires the interface to distinguish things the agent knows from things it inferred.
- Attach evidence to claims, not to the response. A citation list at the bottom is decoration; a link on the sentence it supports is checkable in two seconds.
- Separate read from assumed. "The invoice says $4,200" and "the invoice appears to be for the March engagement" are different epistemic acts, and the second is where errors live.
- Skip the confidence percentage. Models are poor at verbalising their own uncertainty, and a number renders as precision the model does not have. Show the evidence and let the reader judge — that is calibration you can actually earn.
- Make failure loud. The worst state an agent can present is silent partial success: eight of ten records updated, reported as done. Partial completion needs to look different from completion, not merely be mentioned.
Design the waiting, and design the exit.
Agents run for minutes, not milliseconds, which breaks the request-response assumptions of every UI pattern you already own.
- Narrate the current step, not a spinner. "Searching the invoice archive" tells the user whether the agent understood the task — the earliest possible moment to catch a wrong turn. Streaming makes the wait legible; it does not make it shorter.
- Interruptible beats fast. A visible stop button is a UX affordance and a safety control at once, and it changes how much autonomy a user will tolerate. Below it sits the operational version, the kill switch.
- Undo beats confirm. This is the inversion worth internalising: cheap, reliable undo lets you delete confirmation prompts, and the prompts that survive are then rare enough to actually get read. Every dialog you add to a common path trains the user to dismiss the next one.
- Long runs need a handoff, not a held hostage. Let the user leave; notify on completion. An agent that requires an open tab has capped its own usefulness at the length of a coffee break.
If you change one thing this week, replace your "the agent will now do X — OK?" dialog with a plan the user can edit, and put a working undo behind every write. Confirmation dialogs train people to click yes; an editable plan and a real undo are the two surfaces that keep review cheap without lowering autonomy. Measure the result as time-to-approve on real tasks — if it is not falling, your interface is not improving, whatever the model is doing.
Related: autonomy levels for how much rope to give, observability for the trace behind the summary, and designing for trust for the pattern catalogue.