AI Agent UX Patterns: 2026 Glossary and Control Stack
TLDR
AI agent UX patterns are repeatable interface solutions for delegation, supervision, and recovery when working with AI systems that can plan, use tools, and take real-world action. They go far beyond chatbot UX. This glossary defines the key terms, from intent previews and autonomy dials to action receipts, audit trails, and rollback, organized by a six-layer control stack: Intent, Boundaries, Execution, Judgment, Commitment, and Recovery. If your product includes an AI agent that can change data, send messages, or trigger workflows, these are the patterns that make it safe enough to ship.
Why AI Agent UX Needs Its Own Vocabulary
AI agents are not chatbots with better models. A chatbot answers questions. An agent plans steps, calls tools, changes records, sends emails, and makes decisions with limited human supervision. That difference changes everything about UX.
Microsoft defines agents as AI assistants that execute tasks with or for humans using components like instructions, knowledge, actions, skills, and memory. Agentic systems are one or more agents that can autonomously identify, plan, and take actions with limited direct human supervision source. Anthropic draws a related distinction: workflows follow predefined code paths, while agents dynamically direct their own processes and tool usage source. OpenAI’s Agents SDK defines an agent as an LLM configured with instructions, tools, handoffs, guardrails, and structured outputs source.
Those are not marketing definitions. They describe systems that act. And when software can act on a user’s behalf, the UX challenge shifts from conversation design to something much harder: helping people state intent, set boundaries, monitor progress, understand decisions, approve risky steps, and undo mistakes.
That is what AI agent UX patterns are for.
The market confirms the urgency. McKinsey’s 2025 survey found that 23% of respondents were scaling an agentic AI system somewhere in their enterprise, with another 39% experimenting source. But Gartner predicts more than 40% of agentic AI projects will be canceled by end of 2027, largely because of escalating costs, unclear value, or inadequate risk controls source. Deloitte found that about 80% of organizations lack mature governance capabilities like clear autonomy boundaries, real-time monitoring, and audit trails source.
The vocabulary in this glossary is the vocabulary teams need to close that gap. For a deeper guide on applying these patterns in practice, see the complete guide to UX patterns for agentic AI.
Agent UX in One Minute
A chatbot answers “What is your refund policy?” An agent checks the policy, looks up the customer’s order, evaluates eligibility, prepares the refund, asks for approval, executes it, updates the CRM, and sends the customer a confirmation.
That second scenario needs patterns the first one does not.
| Chatbot UX | Agent UX | |
|---|---|---|
| Core interaction | Conversation and response | Delegation, tool use, supervision, recovery |
| User role | Asker | Delegator and supervisor |
| Visibility need | Answer quality | Action status, tool calls, state changes |
| Control need | Regenerate, edit | Approve, pause, stop, rollback |
| Accountability | Citation, source | Audit trail, action receipt, run record |
| Failure mode | Wrong answer | Wrong action with real-world consequences |
HatchWorks frames agent UX patterns as the control surface for the human-agent relationship: how people define goals, grant tool access, supervise execution, and recover safely source. That is the right frame. A chat box can capture intent. It cannot, by itself, provide accountability.
The Agent UX Control Stack
Most articles mix input patterns, trust patterns, and governance patterns together. That makes them hard to use as a design reference. A clearer approach is to organize agentic UX patterns by what they solve, layer by layer.
Layer 1: Intent. What does the user want the agent to accomplish?
Layer 2: Boundaries. What is the agent allowed to do?
Layer 3: Execution. What is the agent doing right now?
Layer 4: Judgment. Why is the agent doing this, and how sure is it?
Layer 5: Commitment. When does an agent proposal become a real-world action?
Layer 6: Recovery. What happens when the agent is wrong?
Every AI agent UX pattern in this glossary maps to one of these layers. When designing an agentic product, working through the stack layer by layer ensures you are not just building a chat window and calling it done.
For a framework that extends this into measurable control surfaces and metrics, see agentic software UX patterns, controls, and metrics.
Foundational Concepts
AI Agent
An AI system configured to pursue a task using instructions, tools, context, and sometimes memory, handoffs, guardrails, or structured outputs. A useful AI agent does more than answer. It decides what step to take next, calls tools, asks for missing information, and reports results.
Agentic System
A system made of one or more AI agents that can identify, plan, and take actions on behalf of users, groups, or other agents with limited direct supervision. A single agent might draft an email. An agentic system might research a customer issue, query CRM data, draft a refund, ask for approval, update records, and notify the customer.
Agent UX
The user experience of delegating work to an AI agent and staying informed, in control, and able to recover. Agent UX includes chat, but also dashboards, taskboards, approval flows, activity timelines, memory settings, permission controls, receipts, and rollback states.
Agentic Experience Design
A design approach for dynamic, intent-based systems where users and agents coordinate across tools, platforms, permissions, and time. Salesforce describes this as a shift from interface-centric to intent-centric design, where dynamic systems adapt to user intent and agent capabilities in real time source.
Workflow vs. Agent
A workflow follows predefined paths. An agent dynamically decides steps and tool use. If every step is known in advance, design it like automation. If the system can re-plan, choose tools, or act under uncertainty, design it like an agent, with visibility, guardrails, and recovery.
Agent-as-User (AX)
The idea that agents are becoming users of systems too, and therefore need reliable endpoints, structured feedback, deterministic contracts, and machine-usable workflows. Practitioners on Reddit describe this as “dual UX”: one layer for humans, and deterministic tool access for agents source.
Intent and Input Patterns
These patterns help users express what they want the agent to accomplish.
Intent Capture
Helping users express a goal, not every step. “Find three vendors, compare pricing, and prepare a shortlist” instead of a sequence of manual commands. Agentic UX shifts from command-based to intent-based interaction source.
Structured Prompt
A guided input pattern that gives users fields, constraints, or templates so the agent receives enough detail. A sales outreach agent, for example, asks for target persona, offer, tone, excluded claims, and approval level before generating a sequence. Structured prompts reduce ambiguity and make downstream actions safer.
Prompt Template
A reusable prompt that captures a known task format. “Summarize this support ticket and suggest next steps” or “Create a product requirements draft from these notes.” Templates prevent users from starting every interaction with a blank text box source.
Reference Material
Users attach or select files, URLs, records, or datasets that the agent must use as context. This scopes the agent’s work and reduces invented context. A legal agent, for instance, reviews a contract against the company’s latest negotiation playbook.
Guided Conversation
A step-by-step conversational pattern where the agent asks questions in sequence. Best for structured, low-to-medium complexity tasks where users need confidence. UX Design Institute lists this as especially useful for goal-oriented tasks source.
Mixed-Initiative Interaction
A pattern where both the user and the agent can take the lead. A co-writing agent suggests edits while the user writes, but the user can override, ignore, or redirect at any point.
Autonomy and Control Patterns
These patterns determine what the agent is allowed to do and when it must stop and ask.
Autonomy Level
A selectable permission that determines whether the agent can suggest only, draft for review, execute after approval, execute low-risk tasks automatically, or operate fully autonomously within policy. HatchWorks recommends defaulting to low autonomy for first-time workflows source.
Autonomy Dial
A UI control that lets users or admins adjust the agent’s independence. A finance agent might auto-categorize expenses but require approval before sending reimbursements. Smashing Magazine identifies this as a pre-action pattern for calibrating trust with progressive authorization source.
Intent Preview (Plan Summary)
A pre-action pattern where the agent shows what it is about to do before it acts. “Here is my plan: cancel old booking, reserve new booking, notify hotel, email updated itinerary. Proceed?” This is the foundational moment of consent, especially before irreversible actions.
Suggest-and-Confirm
The agent proposes an action and waits for user confirmation. Best for email, customer communication, finance, legal, and any context where accountability stays with the human.
Approval Gate
A checkpoint that blocks the agent from taking a risky, costly, irreversible, or policy-sensitive action until a human or policy system approves. “Approve sending this refund?” with amount, customer, source policy, and rollback options visible.
Practitioners on Reddit warn that a single final approve button is often too shallow for long tasks. One builder argued that final approval can be too late if the agent has already mutated records or consumed resources. Another suggested treating approval as a durable artifact tied to a specific execution attempt, not a loose chat message source.
Human-in-the-Loop
A pattern where a human actively reviews, corrects, approves, or redirects the agent before or during execution. This is not just “show a modal at the end.” It should include meaningful checkpoints, clear consequences, and enough context for the human to judge. One LinkedIn practitioner argues that human-in-the-loop is a control design problem, not merely a UX feature, governing when an agent pauses because approval is required or uncertainty is high source.
Human-on-the-Loop
A supervisory pattern where the agent runs mostly autonomously while humans monitor, intervene, pause, or escalate when needed. Best for background agents, monitoring agents, support triage, and low-risk automation with clear alerts. Requires dashboards, activity streams, alerts, pause/resume controls, and audit trails.
Start, Stop, Pause, Resume Controls
Explicit controls for long-running or asynchronous agent work. HatchWorks argues that if an agent runs autonomously but users cannot start, stop, pause, or resume it, the agent has agency but the user does not source.
Kill Switch
A high-priority control that immediately stops an agent or a class of agent actions. Examples: stop all outbound emails, stop all database writes, stop all API calls over a threshold, stop repeated actions.
One practitioner on Reddit described an agent running up about $400 in API calls overnight and recommended hard limits: max calls per minute, max spend per session, and a kill switch for repeated actions source.
Execution Visibility Patterns
These patterns answer: “What is the agent doing right now, and what did it change?”
Agent Status
A visible indication of what the agent is doing at any moment. Common states include waiting for input, planning, calling tool, reviewing result, needs approval, paused, failed, completed, and rolled back. Microsoft says agent status should be clearly visible at all times source.
In Figma, these agent UX patterns translate directly into component states and variants. For practical guidance on building these, see Figma component states: a guide to best practices.
Taskboard
A board or list showing goals, tasks, subtasks, owners, statuses, and outcomes. HatchWorks calls this a high-impact pattern for teams moving beyond demo stage, because users manage work like work instead of reading a chat transcript source.
Activity Timeline
A chronological log of agent decisions, tool calls, state changes, and artifacts. “10:02 searched CRM. 10:03 found duplicate account. 10:04 requested approval to merge.” This is the backbone of post-action accountability.
Tool-Call Ledger
A structured record of every tool the agent called, including inputs, outputs, timestamps, status, latency, and errors. One Indie Hackers practitioner described logging every tool invocation as a structured event, comparing it to an OpenTelemetry span pattern for agent tool calls source.
Run Record
A complete record of an agent run: initial user intent, context, tools used, approvals, state changes, outputs, errors, and final outcome. Practitioners on Reddit argued that enterprise accountability needs reviewer-grade run records by default source.
State Diff
A before-and-after comparison of what the agent changed. “CRM field changed from Lead Status: New to Lead Status: Qualified.” State diffs are the difference between “Done!” and “Here is exactly what changed.”
Action Receipt
A post-action confirmation that shows what the agent changed, where, under which permission, when, and how to undo or inspect it. Example: “Refund issued: $42.19. Policy: refund window under 30 days. Ticket: #4812. Undo available for 10 minutes.” If an agent can change state, the interface needs a receipt.
Agent Inbox
An inbox-like interface where agents surface tasks, draft actions, questions, or approval requests for human review. Best for ambient or background agents that do work outside the active chat session.
Trust, Explanation, and Uncertainty Patterns
These patterns help users decide whether to accept, correct, or reject the agent’s output.
Confidence Signal
A visible cue communicating how certain the agent is. “High confidence: matched company refund policy” or “Low confidence: conflicting dates found.” Google’s People + AI Guidebook says confidence display can affect user decisions and teams should account for situational stakes when showing confidence source. Microsoft adds that the level of certainty and reasoning behind recommendations should be visible or accessible to avoid overreliance source.
A common question is how to display confidence without creating anxiety. Practitioners on Reddit’s UXDesign community recommend showing reasoning or sources when it matters, separating draft from final commitment, and avoiding both false confidence and raw uncertainty source.
For a deeper framework on building trust into agentic products, see product design for agentic AI: trust layers.
Explainable Rationale
A concise explanation of why the agent recommended or took an action. “I selected this vendor because it meets the budget, delivery window, and compliance requirement.” Microsoft’s HAX guidelines (distilled from more than 150 design recommendations and more than 20 years of human-AI interaction research) say systems should make clear why they did what they did source.
Citation and Source Grounding
A pattern that shows which sources support an AI-generated answer or action. A research agent cites the source document and highlights the exact contract clause used. Both AI UX Patterns and The Shape of AI include citations as a core trust pattern source.
Footprints
A traceable path from prompt to output showing the steps, references, or decisions behind an AI result. The Shape of AI defines footprints as letting users trace the AI’s steps from prompt to result source.
Disclosure
A label or cue that tells users when content, action, or interaction is AI-assisted or AI-generated. “Drafted by AI,” “AI suggested,” “Agent updated this field.”
Calibration
Designing the interface so users neither over-trust nor under-trust the agent. Show low-confidence warnings for ambiguous cases, but do not overwhelm users with raw uncertainty for low-risk tasks. This is one of the hardest AI agent UX patterns to get right because it depends entirely on context and stakes.
Recovery and Accountability Patterns
These patterns exist because agents will be wrong, and when they are wrong, they will have already done something.
Undo and Rollback
A recovery pattern that reverses or mitigates the agent’s action. Undo a CRM update, revert a generated file, cancel a queued email, restore a previous configuration. Action-taking agents need recovery because mistakes affect real systems.
Safe Failure
A pattern where the agent fails in a way that limits damage and helps the user continue. If the agent cannot confirm policy, it drafts a recommendation instead of executing the refund. Google’s People + AI Guidebook says AI systems are probabilistic and will fail at some point, so products need to provide ways for users to continue their task source.
Escalation Path
A path for moving from agent handling to human handling when risk, uncertainty, or complexity exceeds the agent’s boundary. Escalate to a support manager when a refund exceeds policy, or to legal when a contract clause conflicts with standard terms.
Manual Mode
A fallback state where the user can complete the task without the agent. “Switch to manual form” when the agent cannot resolve the issue. This is not a failure of the agent, it is a success of the UX.
Approval Artifact
A durable record proving that a specific person or policy approved a specific action under specific conditions. One practitioner on Reddit described approvals as tokenized state transitions: store the pending request durably, issue a short-lived receipt on approval, then verify the receipt and policy context during execution source.
Audit Trail
A complete, reviewable log of all agent decisions, actions, approvals, and outcomes. On Hacker News, commenters praised mandatory approval plus audit logging as a pattern for agentic systems, then asked about DOM snapshots, checkpoints, and redaction strategies source. Audit trails are becoming product primitives, not compliance afterthoughts.
Memory and Personalization Patterns
These patterns control what the agent knows about the user and how it applies that knowledge.
Memory Indicator
A UI cue showing what the agent remembers or is using as context. “Using your preferred tone: concise and technical” or “Remembered: always exclude weekends when scheduling.” Practitioners on Reddit’s AI_Agents community list memory indicators as an evolution of classic chatbox agent interfaces source.
Memory Control
A settings or inline control that lets users view, edit, delete, or disable what the agent remembers. The Shape of AI defines memory as a governor pattern for controlling what details the AI knows about the user source. Microsoft says users should control settings, preferences, personalization, and when the agent is on or off.
Incognito Mode
A pattern where the user can interact without saving the exchange to memory. “Do not remember this conversation.”
Context Engineering
The practice of giving the agent the right information, tools, state, and constraints at the right time. Better UX often comes from better context boundaries, not longer prompts. This is an infrastructure pattern, but designers need to know it because it determines what the agent can and cannot do well.
For products where agents run in the background and build context over time, the agentic SaaS onboarding guide covers how memory and personalization patterns connect to first-run experiences.
Multi-Agent and Orchestration Patterns
As agentic systems grow more complex, the interface must show how agents coordinate.
Multi-Agent System
A system where multiple specialized agents coordinate on a task. UXMag describes a flow where a supervisor AI agent launches specialized worker agents, gathers findings, and returns suggestions to the human operator source.
Supervisor and Worker Agents
A supervisor agent delegates work to specialist agents and synthesizes their outputs. A support supervisor might ask one worker to check logs, another to inspect CRM records, and another to draft a response. The UX challenge is showing users what is happening across agents without overwhelming them.
Handoff
A transfer of control from one agent, tool, or human to another. OpenAI’s Agents SDK includes handoffs as a core multi-agent design pattern source.
Multi-Agent Threading
A UX pattern that shows parallel or nested agent workstreams. A main thread shows the user conversation while subthreads show research, data validation, or specialist-agent loops. Practitioners on Reddit name this as an emerging pattern and note that subagent activity may need to be abstracted away for cleaner UX source.
Agent-to-UI (A2UI)
A pattern where the agent chooses or populates interface components instead of only generating text. The agent responds with a comparison table, order status card, editable form, or approval dialog. A LinkedIn practitioner argues that wall-of-text chat is wrong for many enterprise tasks and describes A2UI as the agent dynamically selecting and populating cards, tables, forms, or charts based on context source.
Dynamic UI (Just-in-Time UI)
An interface that appears or changes based on the user’s intent, current task, or agent output. A scheduling form appears inside chat only when the agent detects a scheduling task. Reddit’s emergent-patterns thread identifies this as a growing direction among agent builders source.
Sidecar Agent
An agent that stays beside the user’s primary work surface. A coding agent in an IDE sidebar or a legal analysis agent beside a contract. Effective because they preserve context and avoid app switching.
Agent-to-Agent Protocol (A2A)
An open standard for agents from different vendors or frameworks to communicate, delegate subtasks, and coordinate. Google’s A2A protocol supports enterprise-grade authentication and user experience negotiation source.
Infrastructure Terms Designers Should Know
Designers building agentic interfaces benefit from understanding these terms, even if they are primarily engineering concepts.
Tool Call
A structured request from an agent to an external function, API, database, or service. Example: create_refund(customer_id, amount, reason). Every meaningful tool call needs a UX state: pending, approved, running, succeeded, failed, retried, or rolled back.
Tool Schema
A typed definition of what inputs a tool accepts and what outputs it returns. HatchWorks argues that typed tool schemas produce validated input forms and clearer error messages source.
Guardrail
A rule, validation, or policy that constrains what the agent can accept, output, or do. “Do not send emails containing protected health information.” “Do not process refunds over $500 without manager approval.” OpenAI’s Agents SDK treats guardrails as part of agent configuration source.
Observability and Tracing
The ability to inspect what the agent did, which tools it used, what happened at each step, and where failures occurred. Without observability, debugging agent behavior is guesswork.
Idempotency
A property of an action where repeating it does not create duplicate or unintended side effects. If a refund request is retried, it should not issue two refunds.
Least Privilege
Giving the agent only the permissions it needs for a specific task. Allow “read calendar availability” but not “delete events.” Practitioners on Reddit compared raw logins for agents to handing out chainsaws without guards and recommended delegated, scoped access with short-lived credentials source.
Model Context Protocol (MCP)
An open standard introduced by Anthropic for connecting AI assistants or agents to external data sources and tools source.
Anti-Patterns to Avoid
Not every agentic UX pattern is good. These are the ones to stop using.
Chat-Only Control
Relying on a chat thread as the only way to monitor, correct, approve, and recover agent work. Chat becomes impossible to parse when work is asynchronous, multi-step, or state-changing. HatchWorks lists invisible actions, unclear state, no controls, no recovery, and no accountability as common chat-first failures source.
Black-Box “Done!”
The agent says a task is complete without showing what changed or whether the external system accepted the action. Indie Hackers practitioners described “hallucinated success,” where an API returns an error but the agent says “Done!” Mitigations include validating HTTP status and response body, schema validation, explicit success/error checks, and logging source.
Approval Theater
An approval modal that appears without enough context, consequence, timing, or binding to the execution attempt. Users approve blindly, approvals become detached from actual execution, and accountability is weak.
Invisible Memory
The agent remembers or uses personal information without showing what it knows or how to change it. Users cannot calibrate trust or correct personalization.
Unbounded Autonomy
The agent can take action without scoped permissions, rate limits, spend limits, or rollback. The $400-overnight-API-spend story from Reddit is a warning, not an edge case.
Screenshot-Only Automation
An agent interacts with UI pixels without using structured APIs, accessibility layers, or native system controls. One Reddit practitioner argued that accessibility APIs preserve native confirmation dialogs, undo support, and OS safety rails, while screenshot agents can become “blind-clicking pixels” source.
How to Choose the Right AI Agent UX Pattern
The best pattern depends on what the agent can do and what happens when it is wrong.
| If the agent… | Prioritize these patterns |
|---|---|
| Only generates text | Prompt template, citations, regenerate, edit, feedback |
| Summarizes or recommends | Confidence signal, rationale, source grounding, correction path |
| Drafts an action | Intent preview, suggest-and-confirm, draft state |
| Changes data | Approval gate, action receipt, state diff, rollback |
| Runs in the background | Agent inbox, notifications, activity timeline, pause/resume |
| Uses multiple tools | Tool-call ledger, permissions, run record, observability |
| Uses multiple agents | Supervisor/worker view, handoffs, multi-agent threading |
| Handles high-risk work | Least privilege, audit trail, escalation, manual mode, governance |
No single interface type has won yet. Practitioners on Reddit observe six current directions: classic chatboxes with structured outputs and memory indicators, multi-agent threading, drag-and-drop canvas builders, dynamic/JIT UI, agent app stores, and side-window agents source. The winning approach will likely be different for different products. What will not change is the need for visibility, control, and recovery.
If you are evaluating your current product’s UX against these patterns, a UX audit for B2B SaaS is a practical starting point for identifying gaps.
Bringing It Together
AI agent UX patterns are the design vocabulary for controlled delegation. The user should know what the agent can do, what it is doing, why it is doing it, when it needs approval, what changed, and how to recover. If a pattern does not improve intent, boundaries, execution visibility, judgment, commitment, or recovery, it is probably decoration.
The market is moving fast. Gartner predicts 33% of enterprise software applications will include agentic AI by 2028, up from less than 1% in 2024 source. But adoption without the right UX patterns will produce fragile, opaque autonomy that teams cannot trust, audit, or recover from.
The library at thiagopatriota.com focuses on high-craft UX/UI for agentic software, AI-native workflows, and developer-ready design systems. For teams building products where AI can act, the patterns in this glossary are the foundation. Explore the full collection of books and frameworks for structured thinking beyond a single article.
FAQ
What are AI agent UX patterns?
AI agent UX patterns are repeatable interface solutions for designing how people work with AI systems that can plan, use tools, take action, and recover from mistakes. Common patterns include intent previews, autonomy dials, approval gates, activity timelines, confidence signals, action receipts, audit trails, and rollback. They help users delegate work while staying informed and in control.
How are AI agent UX patterns different from chatbot UX patterns?
Chatbot UX focuses on conversation: the user asks and the bot responds. Agent UX focuses on delegation: the user gives a goal, the agent plans steps, uses tools, takes action, asks for approval, and shows what changed. That requires stronger patterns for visibility, control, and accountability that conversational interfaces alone cannot provide.
What is an autonomy dial?
An autonomy dial is a UI control that lets users or admins set how independently an agent can act. Levels typically range from “suggest only” through “draft for review” to “execute low-risk tasks automatically.” Smashing Magazine identifies it as a pre-action pattern for calibrating trust with progressive authorization.
What is human-in-the-loop UX for AI agents?
Human-in-the-loop UX is the design of review, correction, approval, and escalation points inside an AI workflow. It is not just one final approve button. Good human-in-the-loop design gives the reviewer enough context, clear consequences, and a specific binding between the approval and the action being taken.
Why do AI agents need audit trails?
AI agents can take actions across systems. If an agent updates a record, sends an email, changes a permission, or triggers a payment, users and teams need to know what happened, why, who approved it, and how to recover. Without audit trails, accountability is impossible at scale.
What is the difference between an AI workflow and an AI agent?
An AI workflow follows predefined steps. An AI agent can dynamically decide which steps or tools to use. Workflows are easier to predict. Agents need more visibility, constraints, and recovery patterns because they operate with more autonomy. Anthropic draws this distinction explicitly in their engineering guidance.
What is Agent-to-UI (A2UI)?
Agent-to-UI is a pattern where the agent returns structured interface components instead of only text. Instead of a wall of text, the agent might show a comparison table, editable form, approval card, or chart. This makes agent outputs more usable and actionable, especially in enterprise contexts.
Do all AI products need agent UX patterns?
No. If the AI only generates text or summarizes information, basic patterns like citations, regenerate, edit, and feedback may be enough. Agent UX patterns become important when the AI can take actions, change data, use tools, run in the background, or coordinate with other agents.
