Agentic products are software that doesn't just answer — it acts on the user's behalf: it books, buys, files, writes, and executes multi-step tasks.
A search engine returns results and waits. An assistant that answers questions still leaves every action to you. An agent is different. You tell it "find me a flight to Lisbon under 300 euros and book it," and it searches, compares, fills in the details, and pays.
That single shift changes almost everything about the design problem. When software acts instead of merely responding, the cost of a wrong action is no longer a bad answer — it's a booked flight, a sent email, or a spent budget. Designing for agents means designing for consequences.
In a traditional interface, the user drives every step: they tap, type, confirm, and move to the next screen. The designer's job is to make each step obvious. In an agentic product, the user states a goal, hands it over, and supervises. The steps in between belong to the agent.
You are no longer designing a sequence of screens — you are designing a delegation relationship. The questions change accordingly. Not "is this button clear?" but "does the user know what they just authorized?" Not "can they complete the flow?" but "can they see what the agent is doing, correct it mid-course, and reverse it afterwards?"
Everything you already know about trust in AI interfaces still applies here; this article focuses on the patterns specific to software that acts.
Six patterns come up in almost every agentic product. Together they answer the user's three constant questions: what is the agent allowed to do, what is it doing right now, and how do I take back control?
Before an agent acts, the user needs to define what exactly it may do. Vague permission ("help me with my inbox") invites unwelcome surprises. Good scoping is granular: this account but not that one, drafts but not sends, purchases up to a set amount.
Spend limits and action limits are the workhorses here. A travel agent that can book anything under 300 euros without asking, but must check in above that, matches how people delegate to other humans. Design the scope-setting moment as a first-class flow, not a wall of toggles buried in settings.
Before executing, the agent should show its intent: "Here's what I'm about to do — search these three sites, compare prices, book the cheapest refundable option." A visible plan lets users redirect the agent before anything happens, which is always cheaper than undoing it after.
Keep plans scannable: a short list of steps, with the consequential ones (payment, sending, deleting) clearly marked. A plan the user won't read protects no one.
While the agent works, the user should be able to see what it's doing now, what's already done, and what failed. This is the difference between trust and a black box. A silent spinner for ninety seconds feels broken; a live step list ("comparing fares... done") feels supervised.
Failures deserve the same visibility as successes. An agent that quietly skips a failed step and reports "all done" is teaching the user that its summaries can't be trusted.
Users must be able to pause, stop, or take over mid-task — without losing state. If someone pauses a research agent halfway through, the work done so far should survive: the sources found, the draft started, the form half-filled. Stopping the agent should never mean starting over.
Taking over is the underrated case. Sometimes the user just wants to finish the last step themselves. Hand them the current state cleanly, the way a colleague would hand over a half-finished document.
Some actions should always pause for explicit approval: payments, sending messages to other people, deleting data. The rule that decides where gates go is reversibility. If an action can be undone in one tap, let the agent proceed; if it can't, put a confirmation gate in front of it.
Resist the temptation to gate everything. An agent that asks permission for every trivial step is just a slower form. Gates are for consequences, not for cover.
Agents work while users are away, so every agentic product needs a clear answer to "what happened while I was gone?" An audit trail — a readable log of actions taken, in plain language — is the minimum. Pairing each entry with an undo or reverse action is the goal.
Write the log for humans, not machines: "Rescheduled your dentist appointment to Thursday" beats a timestamped event dump.
Agents fail in ways buttons don't. They hit dead ends: the site is down, the item is out of stock, the form rejects their input. And they act on wrong assumptions: booking the 6am flight because "early" meant something different to you.
Graceful failure means two things. First, the agent stops digging — it recognizes a dead end instead of retrying forever or improvising something the user never asked for. Second, it hands back control with context: what it tried, where it got stuck, what it recommends next, and everything it has gathered so far. A good failure handoff turns "the agent gave up" into "the agent got me 80% of the way and told me exactly what's left."
When the agent errs, the product owns it. Blaming the AI is not a pattern.
If the agent books the wrong hotel, the user experience of that mistake — the apology, the fix, the refund path — is your design responsibility. Error messages that shrug ("the AI made a mistake") shift blame onto a system the user can't inspect or argue with. Classic error design says never blame the user; agentic design adds: never blame a scapegoat either.
Design the repair path with the same care as the happy path: acknowledge the error plainly, show what happened, and offer the fastest route to making it right.
Trust between a user and an agent should grow the way it grows between people: gradually, through demonstrated competence. Start the relationship small — drafts before sends, suggestions before purchases, one calendar before all of them. As the agent proves itself, invite the user to widen the scope.
The failure modes sit at both extremes. Users who under-trust never delegate anything and get no value; users who over-trust hand over everything on day one and get burned. Your job is calibration: let the agent start small and earn scope, one demonstrated success at a time.
Agentic UX is the design of a delegation relationship: scope what the agent may do, show its plan and progress, gate the irreversible, and make everything auditable and undoable.
When the agent fails, hand control back with context. When it errs, own the mistake. And let trust grow the honest way — small scope first, more scope earned.