Agentic UX patterns: plan, progress, interrupt, hand off

The happy path of an agent product nearly designs itself. The user asks, the agent does the thing, everyone is pleased. Almost none of the design work lives there. It lives in the moments when the agent is unsure, wrong, slow, or out of its depth, and the person on the other side has to decide whether to trust it.

I’ve argued elsewhere why design moves underneath the agent, and I’ve laid out a vocabulary for the agent ladder. This piece is the practical third part: what to actually draw. It’s a catalog of the patterns I reach for as a Head of Design working on agent products, each with the failure state that tells you whether the pattern is doing its job.

Why a catalog at all

Teams building their first agent tend to invent every interaction from scratch, usually inside a chat box. A shared catalog does three things:

  • It gives product, design and engineering the same nouns. "Add a plan step here" is a faster conversation than a whiteboard session.
  • It makes gaps obvious. If a flow has no interrupt pattern, you can see it in review before users find it.
  • It forces every pattern to declare its failure state. A pattern without one is decoration.

1. Plan before act

What it is. Before the agent does anything with consequences, it says what it intends to do, in what order, and with what scope.

What the UI shows. A short, editable plan: three to seven steps, each in plain language, with anything destructive or external marked. Scope is explicit: which files, which records, which account. The user can approve, edit a step, or remove it.

When to use it. Any time the agent will write, send, delete, spend, or touch something another person will see. For read-only lookups, a plan step is friction; skip it.

Failure state. The plan is vague ("I’ll update the relevant items"), or the agent quietly does something that wasn’t on it. Plans that don’t match actions destroy trust faster than having no plan.

2. Progress you can trust

What it is. While the agent works, the user can see that it is working, roughly where it is, and what it has found.

What the UI shows. Steps that stream in as they happen, each collapsing to a single line once done. A "show its work" expander for anyone who wants the trace. Elapsed time for long jobs, and an honest label when something is waiting on an external system rather than thinking.

When to use it. Anything longer than a couple of seconds, and anything where an intermediate result changes what the user wants next.

Failure state. A spinner with no information, or a wall of log text nobody reads. The first hides the work. The second hides the work in plain sight. The useful middle is a summary line per step, with detail on demand.

3. Interrupt and undo

What it is. The user can stop the agent at any point, change direction, and reverse what it did.

What the UI shows. A stop control that’s always visible and always one action away, never buried in a menu. Edit-the-plan while the agent is mid-run. Proposed changes presented as a diff the user can accept or reject in pieces rather than all or nothing. After the fact, a clear undo with a description of what will be reverted.

When to use it. Always, for any agent that changes state. The cost of building it is small compared with the cost of one irreversible mistake.

Failure state. Stop that doesn’t actually stop (the agent finishes the current batch anyway), or undo that reverts only part of what happened. Test both with real timing, not in a mockup.

4. Ask one good question

What it is. When the agent is missing something it needs, it asks a single, specific question instead of guessing a default.

What the UI shows. One question, with the most likely answers offered as options and a free-text escape. Context for why it’s asking: "The brief has two different launch dates. Which one should I use?"

When to use it. When a wrong guess would be costly or embarrassing, and when the answer isn’t recoverable from context the agent already has.

Failure state. Two opposite failures. The agent guesses silently and is confidently wrong, or it asks five questions up front like a form. Teach it to ask the one question that unblocks the most.

5. Hand off to a human

What it is. When the agent is out of its depth, it passes the work to a person with everything they need to continue.

What the UI shows. A clear statement that the agent is handing off and why. A context packet the human can read in under a minute: what was asked, what was tried, what was found, what is still unknown. A visible owner and a way for the original user to see status.

When to use it. Thresholds you define in advance: low confidence, high stakes, policy boundaries, or repeated failure on the same step.

Failure state. The handoff drops context, and the human has to start over by asking the customer the same questions. That’s worse than no agent at all.

This one has deep roots for me. At Plume, the ISP dashboards were tools for support teams: portals and utilities so a person could see a home network’s state and act on it. Today I’d design the escalation between roles explicitly, so the next person gets a full context packet instead of a ticket number. The pattern is the same whether the sender is a human or an agent.

6. Suggest, then let the user correct

What it is. The agent proposes an action inline, and the user accepts, edits, or dismisses it with minimal effort.

What the UI shows. A suggestion that sits where the user is already looking, accepted with one motion, editable in place, and silent when confidence is low.

When to use it. Repetitive, well-scoped work where the agent is right most of the time.

Failure state. Suggestions that are right too rarely to be worth reading, or that are hard to correct. Handle, a product I designed that turned email into tasks and placed second at TechCrunch Disrupt, was an early bet on exactly this posture: collapse inbox noise into the next action. The Handle case study has the details. The lesson that carried forward: the design question is the correction, not the suggestion.

The catalog at a glance

PatternWhen to useWhat the UI showsFailure state
Plan before actWrites, sends, deletes, spendsShort editable plan with explicit scopeVague plan, or actions that don’t match it
Progress you can trustAnything longer than a few secondsStreamed steps, collapsible traceSilent spinner or unreadable log
Interrupt and undoAny agent that changes stateAlways-visible stop, partial accept, clear undoStop that doesn’t stop, partial undo
Ask one good questionMissing input with costly guessesOne question, likely answers, reasonSilent guess, or a questionnaire
Hand off to a humanLow confidence, high stakes, repeated failureReason, context packet, owner, statusContext dropped, user starts over
Suggest, then correctRepetitive, well-scoped workInline suggestion, one-motion accept, edit in placeLow accuracy, or hard to fix

How I use the catalog in review

In design reviews of agent work, I walk each flow and ask the same questions. Where is the plan? Where can I stop it? What happens when it doesn’t know something? Who gets it when it can’t finish? If a flow can’t answer all four, it isn’t ready, no matter how good the happy path looks.

The catalog also makes testing sharper. Each failure state above is a test case waiting to be written, which is how I approach testing agent products before users do. For how these patterns sit inside a broader design pipeline, see AI action stacks.

Agent products earn trust in the uncomfortable moments. Design those first.

Related Design systems with AI: the system is the contract agents build againstTesting agent products before users do: scripted failure cases as the new usability testWhen AI is the UI, design moves underneath

See more workGet in touch