Nobody Knows How to Design for AI Agents Yet. That's the Opportunity.
The user clicked "run." The agent opened eight browser tabs, drafted three emails, updated a spreadsheet, and submitted a form — in that order, without confirming anything, in about 40 seconds. The task completed successfully. The user had no idea what the agent decided along the way, what alternatives it considered, or what it would have done if the form had contained a required field it didn't recognize.
This is the design problem nobody has solved yet: how do you design for a system that acts on your behalf without you seeing it act?
Traditional UX doesn't have the answer. It wasn't built for the question.
Why Interface Design Is the Wrong Frame
Traditional UX is a negotiation between system state and user intention, mediated by interface. The user sees a screen, makes a choice, sees the result. The designer's job is to make that sequence legible — clear affordances, sensible defaults, feedback that confirms what happened. Edge cases get handled by showing them to the user. The user stays in the loop because the loop was designed to require them.
Agentic systems break this model structurally. The agent has goals, context, and autonomy. It makes intermediate decisions the user never explicitly approved. It operates over timeframes where the user has moved on to something else. The interface — if there is one — shows a progress indicator and a result. Everything that happened in between is the system's business, unless the designer deliberately makes it otherwise.
The double-diamond framework — discover, define, develop, deliver — was built for interfaces that present choices to users. An agentic system isn't presenting choices. It's making them. The vocabulary transfers, but the underlying design problems don't.
John Maeda's 2026 Design in Tech Report named this shift as UX to AX: from user experience to agentic experience. The terminology is less important than the implication. When the product's core behavior is autonomous action rather than responsive display, the designer's materials change.
The New Design Materials
When you design a navigation flow, your materials are screens, states, affordances, and feedback loops. When you design for agent behavior, the materials are different:
Trust calibration — How much should the agent be allowed to do before checking in? The answer differs by task, user, context, and what's at stake if the agent is wrong. There's no universal default. Sending an email is reversible in one sense — you can follow up. Deleting files, submitting a payment, updating a public record — the stakes are different. Designing trust calibration means encoding a hierarchy of action stakes and making it legible and adjustable.
Transparency mechanisms — Can the user understand what the agent did and why? This is not the same as showing a log file. It means designing legible explanations of agent decisions at the level of abstraction the user cares about. "Step 14: POST request to /api/v2/forms/submit" is technically accurate and completely useless. "I found the form link in your previous email thread and submitted with the details you gave me" maps to the user's mental model of the task. The translation is a design problem.
Override points — Where should the user be able to interrupt, redirect, or correct the agent mid-task? If the agent is 12 steps into a 20-step process and about to take an irreversible action, the design needs to surface that moment specifically. What does "pause here for review" look like when the agent operates faster than a user's attention cycle?
Error recovery — What happens when the agent acts on a misunderstood instruction or encounters an edge case? Traditional UX handles errors by surfacing them immediately. Agentic errors may not be visible until the task is complete — or until downstream consequences arrive that the user didn't anticipate. Recovery design for agents is a different problem than recovery design for interfaces.
The Autonomy Paradox
The core tension in agentic design is one the field is actively circling: agents that require constant approval feel useless, and agents that act without visibility feel unsafe.
An agent that confirms every action before taking it isn't an agent — it's a guided menu. The value of automation is completing multi-step tasks without requiring continuous user attention. Interrupt that continuity too often and the tool creates more friction than doing the task manually.
An agent that acts without transparency creates a different failure mode. Users grant autonomy to systems they understand and trust. When an agent does things the user can't explain, the rational response is to restrict it — not because the agent is wrong, but because inexplicable competence feels the same as undetectable failure. You can't tell the difference between "I don't understand how this works but it's fine" and "I don't understand how this works and it's about to break something."
Microsoft's design team and Smashing Magazine's 2026 collaboration on agentic AI patterns named this explicitly. Their proposed framework extends the double-diamond with an "Adapt" phase after delivery — a continuous loop where the system and user negotiate the autonomy contract based on what's actually happening in use. The trust calibration isn't a fixed setting. It's an ongoing adjustment.
This is a significantly more complex design problem than "here's the onboarding flow." It requires designing systems that track their own confidence, communicate uncertainty, and adjust their behavior based on implicit user signals — not just explicit preferences.
What Early Patterns Look Like
The teams building this now — primarily at frontier labs and a small number of enterprise software companies — are developing conventions that didn't exist 18 months ago. A few patterns are starting to stabilize:
Action previews with selective confirmation. The agent summarizes what it's about to do in plain language. For reversible actions, it proceeds automatically. For irreversible ones — sending, submitting, deleting — it pauses for approval. Lower friction than confirming everything; still surfaces the moments that actually matter.
Confidence thresholds. The agent handles decisions it's confident about without interruption and surfaces decisions below a confidence threshold for user input. This requires calibrated self-assessment of uncertainty from the underlying model, which is a hard technical problem — but the design frame is correct. The user doesn't want to see everything. They want to see the decisions the system is least sure about.
Natural-language audit trails. Not a log file — a narrative reconstruction after the fact. "I drafted the email from your notes, found that the attachment was in the wrong folder and moved it, then sent at 3:47pm." The user can verify what happened without needing to watch in real time. This shifts transparency from synchronous to asynchronous, which better matches how most users actually want to work.
These patterns are emerging, not established. The designers working in this space are inventing vocabulary in real time, across organizations that aren't coordinating with each other. In ten years, these conventions will be as standardized as the dropdown menu or the notification badge. Right now, they're being written for the first time.
The Accountability Problem Nobody Has Solved
The question the field is circling but hasn't answered: who is responsible when an agent acts incorrectly?
If the agent submits the wrong form because it misinterpreted an instruction, is that a design failure, a model failure, or a user error? The accountability question in AI systems is unresolved at the legal and product level for AI generally. Agentic systems make it more urgent in a specific way: when the system acts on your behalf rather than responding to your choices, the agency relationship becomes ambiguous in ways that traditional software products don't create.
This matters for design beyond the legal question. If users believe agents will be held accountable for their mistakes, they'll extend more trust. If they believe they're responsible for everything an agent does under their account, they'll restrict autonomy tightly enough to defeat the purpose. The design of accountability — how a product communicates who is responsible for what, and what recourse looks like — is part of agentic UX. It just doesn't fit neatly into a Figma file.
The design patterns that emerge from this moment will be adopted widely and fast. When a new interaction paradigm establishes itself, early conventions harden into defaults before the field has time to debate whether they're the right ones. The AI UI commoditization problem is already visible in how interfaces look; agentic behavioral patterns are about to have the same consolidation phase for how products act.
The fact that nobody has figured it out yet is not a reason for pessimism. It's a map of where the work is.
Photo by Alberlan Barros via Pexels.