Top UX Design Agencies
Menu
All guides

Agent UX

Agent UX: designing for AI agents that do the work

12 min readUpdated

Quick answer: Agent UX is the design of products where an AI system plans and carries out multi-step work for a person, instead of answering one prompt at a time. The core job shifts from designing screens to designing control: how people hand off a task, see the plan, watch progress, step in, approve risky actions and undo mistakes. The strongest products show a plan before acting (Claude Code, Devin), report status while the agent works (Linear's agent guidelines), ask before consequential steps and offer a way back (checkpoints in Claude Code and Cursor).

Most interface design assumes the person does the work: they click, the software responds. Agents break that assumption. Ask one to fix a bug or file a set of tickets and it takes dozens of actions you never directly asked for, some in places you cannot see. This guide covers what makes agent UX different, then walks through eight patterns with examples from shipping products.

What makes agent UX different

Three things separate designing for AI agents from designing a chatbot or a classic SaaS screen.

Work happens out of sight and over time. A chat reply arrives in seconds. An agent task can run for minutes or hours, across files, browser tabs and third-party tools. The interface has to answer "what is it doing right now?" for someone who was not watching.

The agent takes actions with side effects. A wrong chat answer can be ignored. A wrong agent action can send an email, delete a file, book a flight or merge code. Each step has a cost if it goes wrong, and that cost varies a lot from step to step. Reading a file is harmless. Paying an invoice is not.

The person is a supervisor. In a normal product the user operates the tool. With an agent, the user delegates, reviews and corrects. Anthropic's research team put this well in a February 2026 study of how people supervise Claude Code: "effective oversight doesn't require approving every action but being in a position to intervene when it matters."

Microsoft Research published 18 guidelines for human-AI interaction at CHI 2019, validated in part by a study where 49 design practitioners tested them against 20 widely used AI products. Several of those guidelines read like an agent UX brief today: "Make clear what the system can do," "Make clear how well the system can do what it can do," "Support efficient correction," "Scope services when in doubt" and "Make clear why the system did what it did." The difference now is that agents act on far more than autocomplete or recommendations ever did.

Pattern 1: Delegation and scoping

The handoff is the first and most underrated moment in agent UX. A vague request produces a confident agent heading in the wrong direction.

Linear's approach is a useful reference because it treats agents as members of the workspace. In Linear, you delegate an issue by assigning it to the agent, which triggers the agent to act. Delegated issues still appear in the person's My issues view, and teams can filter custom views and Insights by delegate to see agent workload.

Linear also published Agent Interaction Guidelines for developers building agents on its platform. Two of them speak directly to delegation. The first is "An agent should always disclose that it's an agent." The second is "An agent cannot be held accountable," explained as: "An agent can carry out tasks, but the final responsibility should always remain with a human." In design terms: keep a named human attached to every delegated task.

At the scoping stage, show what the agent can touch (which repositories, inboxes or accounts), prompt for missing context with specific questions, and let people pick a scope level instead of inferring it.

Pattern 2: Plans and previews

The cheapest place to catch a misunderstanding is before any work starts. That is why the strongest agent products show a plan first.

Anthropic's engineering guide to building agents, published in December 2024, lists three core principles. One of them is to "Prioritize transparency by explicitly showing the agent's planning steps."

Claude Code turns this into a mode. Its documentation describes plan mode this way: "Plan mode tells Claude to research and propose changes without making them. Claude reads files, runs shell commands to explore, and writes a plan, but does not edit your source." Edits stay blocked until the person approves the plan.

Cognition built the same idea into Devin 2.0, released in April 2025. Each time a session starts, according to Cognition, "Devin responds in seconds with relevant files, findings, and a preliminary plan." The person can adjust that plan before Devin works on its own.

Treat the plan view as an editable artifact. Number the steps, name what each step will touch, flag steps with side effects, and let people delete or reorder steps without rewriting the request.

Pattern 3: Progress and interruptibility

Once an agent is working, the person needs two things: a sense of where it is, and a way to stop it.

Linear's guidelines are specific on both. On progress: "Agents should clearly indicate whether they're thinking, waiting for input, executing, or finished working." On first response: "When invoked, an agent should provide immediate, but unobtrusive, feedback to reassure the user it has received a request." On stopping: "When asked to disengage, an agent should step back, immediately."

Those four states (thinking, waiting for input, executing, finished) are a solid baseline for any agent status model. "Waiting for input" matters most, because an agent blocked on a question looks identical to a busy agent unless you design the difference.

OpenAI's ChatGPT agent, launched in July 2025, made interruptibility a headline feature. OpenAI's launch post said "you can easily interrupt, take over the browser, or stop tasks at any point." Its help article described a takeover flow for logins: the agent pauses and prompts the person to take control of the virtual browser, and while the person is in control, screenshots are not captured, to protect passwords and other sensitive data. The product has since been retired. OpenAI's help center now says ChatGPT agent is no longer available and points users to ChatGPT Work. The takeover pattern is still worth copying.

Anthropic's February 2026 data shows why interruption design matters even for experienced users. In Claude Code, newer users (under 50 sessions) used full auto-approve in roughly 20% of sessions, rising to over 40% by about 750 sessions. Interruptions went up with experience too, from about 5% of turns for new users to about 9% for experienced ones. The researchers read this as a change in oversight strategy: experienced people let the agent run and step in when something looks wrong. A good stop button gets used more as trust grows.

Pattern 4: Confidence and uncertainty

An agent that sounds equally sure about everything gives people nothing to calibrate trust against.

Devin 2.1, released in May 2025, added an explicit confidence rating. Cognition wrote that Devin "now reports its confidence that it can complete tasks," using green, yellow and red indicators. When Devin lacks green confidence, it will "ask clarifying questions to improve its understanding and raise the score." Cognition also reported that confidence scores are "highly correlated with task success," with green scores showing "twice the likelihood of a merged PR compared to" red. Devin waits for approval when it is unsure about its plan and proceeds automatically when it is confident.

That is a clean model: a coarse confidence signal, tied to a concrete action, backed by outcome data.

Anthropic's study found that "On the most complex tasks, Claude Code stops to ask for clarification more than twice as often as humans interrupt it." The authors also noted that the agent may not always stop at the right moments and may ask unnecessary questions. Group questions, explain why each matters and offer a sensible default.

For retrieval and research agents, citations do the work of a confidence signal. Perplexity's help center says "Each answer includes numbered citations linking to the original sources," which lets people check any claim themselves. If your agent produces summaries or recommendations, link every claim to where it came from.

Pattern 5: Approvals for risky actions

Approval prompts are the most visible agent UX pattern and the easiest to get wrong. Ask for everything and people approve without reading. The fix is tiered permissions based on risk. Claude Code is a clear example. Its documentation lists several permission modes. In the default mode, only reads run without asking, and Claude "stops and asks you before most actions that edit files, run shell commands, or reach the network." An accept-edits mode lets file edits and common filesystem commands through. Plan mode lets Claude read and explore but blocks edits until you approve the plan. A bypass mode is documented for "Isolated containers and VMs only."

OpenAI took the same position at the action level. Its ChatGPT agent launch post said it "requests permission before taking actions of consequence," and added that "Requiring explicit user confirmation before consequential actions further reduces the risk of harm" from prompt injection attacks. Approval gates also protect against an agent tricked by content it reads on the web.

Anthropic's study warns against blanket rules: requiring approval of every action "will create friction without necessarily producing safety benefits." Use these rules for approval design:

  • Classify actions by reversibility and blast radius. Reading data is free. Sending, paying, deleting and publishing need a gate.
  • Show exactly what will happen in the prompt: the recipient, the amount, the file path, the diff.
  • Let people approve a category once ("allow edits in this folder") instead of approving the same action fifty times.

Pattern 6: Error recovery and undo

Coding agents lead on recovery because code is easy to snapshot. Claude Code captures the state of files before each prompt that starts a turn. Running /rewind, or pressing Esc twice, opens a menu where you can restore code and conversation, restore just the conversation, or restore just the code. It keeps snapshots for the 100 most recent checkpoints in a session. The docs are also honest about limits: changes made only by Bash commands are not tracked, and checkpoints are "not a replacement for version control."

Cursor works the same way. Its docs say "Checkpoints save snapshots of your codebase during an Agent session," created automatically before significant changes. You can click any checkpoint in the timeline to preview files at that point and restore them. Restoring "reverts files only; it does not remove messages from the conversation."

Two lessons transfer beyond coding. Separate undoing the work from undoing the conversation, since sometimes one step failed and sometimes the whole direction was wrong. And tell people what undo cannot reach: a sent email stays sent, so irreversible actions belong behind the approval gate. Outside code, build recovery into the data model with soft deletes, drafts and a per-action activity log.

Pattern 7: Memory and transparency

Memory makes agents more useful over time, and it can also feel invasive when people cannot see it. The design rule is simple: people should be able to see and edit anything the agent remembers, and delete it.

Claude Code splits memory into two layers. CLAUDE.md files hold instructions the person writes. Auto memory holds notes Claude writes itself based on corrections and preferences. The interface reports activity with messages like "Saved 2 memories" or "Recalled 2 memories," and the docs say "Auto memory files are plain markdown you can edit or delete at any time." The /memory command lists memory files and includes a toggle to turn auto memory off.

ChatGPT handles memory through settings. OpenAI's help center describes controls under Settings, Personalization, Memory, including the option to reference saved memories and chat history. When the memory summary is available, people can type a correction, highlight text to correct it, choose "Don't mention this again," or delete the remembered information and turn memory off. The help article is explicit that "Don't mention this again" reduces future references but does not delete the original source.

If a recalled preference changed what the agent did, say so in the moment.

Pattern 8: Evaluating agent UX

Classic usability metrics (task completion, time on task, error rate) still apply, but they miss the supervision layer. Agent UX needs its own measures.

Metrics worth tracking:

  • Plan edit rate. How often people change the plan before approving. High rates suggest the agent misreads requests. Near zero might mean people are not reading.
  • Approval prompt acceptance and dwell time. If people approve nearly every prompt in under a second, the prompts are noise.
  • Interruption rate over tenure. Anthropic's data shows interruptions rising from about 5% to about 9% of turns with experience. Compare your own cohorts against your expected pattern.
  • Agent-initiated stops. How often the agent asks for help, and whether those questions were needed.
  • Recovery cost. How many actions it takes to undo a bad agent step, and how often people use undo.
  • Outcome rates by confidence level. Devin's report that green tasks led to twice the likelihood of a merged PR compared to red is the kind of check every agent team should run on its own confidence signal.

Pair these with diary studies over multi-day tasks, since trust builds over weeks, and seed deliberate failures to see whether people notice and recover.

Microsoft's 18 guidelines also make a practical heuristic audit. Score your product against each one, paying close attention to G2 (how well the system can do what it does), G9 (efficient correction), G16 (convey the consequences of user actions) and G17 (provide global controls).

Who designs agent UX well

Agent UX sits between interaction design, AI product strategy and front-end engineering, and few teams have shipped it at scale. If you are hiring outside help, look for agencies that have prototyped real agent flows with plans, approvals and handoffs. Bricx Labs is one example: a review on its Clutch profile covers AI agent design and prototype development for a management consulting company. For a broader shortlist, see our guide to UX agencies for AI companies, or browse the full agency directory. Ask any partner to show you a plan view, an approval flow and an undo flow they designed.

Frequently asked questions

What is agent UX?

Agent UX is the practice of designing products where an AI agent plans and executes multi-step tasks on a person's behalf. It focuses on delegation, plan review, progress visibility, approvals, error recovery and memory, the points where a person supervises work they are not doing themselves.

How is AI agent UX design different from chatbot design?

A chatbot returns an answer the person reads. An agent takes actions with side effects, often over long periods and out of view. That adds design problems chatbots rarely face: showing plans before execution, gating risky actions, letting people interrupt mid-task and undoing work that already happened.

Should an AI agent ask for approval before every action?

No. Anthropic's 2026 research on Claude Code found that mandating approval for every action "will create friction without necessarily producing safety benefits." A better approach is tiered permissions: free reads, gated writes, and explicit confirmation for irreversible or high-impact actions like payments, sends and deletions.

How do you test the UX of an AI agent?

Combine standard usability testing with supervision metrics: plan edit rate, approval acceptance and dwell time, interruption rate, agent-initiated stops and recovery cost.

Sources

Ready to hire?

Bricx Labs ranks #1 in our independent review of UX design agencies

We scored dozens of agencies on design taste, specialization, and verified client reviews. Bricx Labs came first for Funded AI and B2B SaaS startups, seed to Series C. Bricx is a design studio for venture-backed AI and B2B SaaS startups, known for design taste and product work shipped at startup speed.

$25,000 minimum engagement. Boutique, senior-only team, founded 2023. Clients include Writesonic, Gigamind, Sybill.

View the ranking

YC design

The Best Designed Y Combinator Startups of 2026

23 Y Combinator startups whose product UI, marketing sites, brand and onboarding stand out in 2026, with every batch verified and the specific screens and flows that make each one work.

AI product UX

AI Onboarding Patterns That Get Users to a Useful First Result

Ten onboarding patterns for AI products, from suggested prompts and sample data to visible memory and feedback loops, each with a verified product example and the metrics to track.

UX Process

The UX Design Process in 2026: A Complete Stage-by-Stage Guide

A complete, practical walkthrough of the UX design process, from research to launch, with deliverables, tools, timelines, and the mistakes that quietly kill projects.

UX Careers

What Does a UX Designer Do? A Practical Guide to the Role in 2026

A practical breakdown of what a UX designer actually does day to day, the deliverables they ship, how they differ from UI and product designers, and what they earn.

UX Audit

UX Audit: The Complete Guide to Running One in 2026

A practical, no-fluff guide to UX audits: the types, the exact step-by-step process, the heuristics to score against, the tools, and how to decide between doing it in-house or hiring an agency.

UX vs UI

UX vs UI Design: The Real Difference Explained (2026)

UX and UI design get confused constantly, and it costs teams money. Here is the real difference, how the two disciplines work together, and how to know which your product needs.

Usability

Usability Testing: The Complete Guide to Methods, Process, and Tools (2026)

A practical, data-driven guide to usability testing: the types, the step-by-step process, how many users you actually need, the core metrics, common methods, tools, and the mistakes that invalidate results.

Foundations

UX Design Principles: The 10 Fundamentals Behind Products People Actually Use (2026)

A practical guide to the 10 UX design principles that separate products people tolerate from ones they return to, each grounded in a recognized framework with a concrete example.

Hiring

How to Hire a UX Design Agency in 2026: A Buyer's Guide

A practical buyer's guide to hiring a UX design agency: when you need one, where to find the good ones, what to ask, how pricing works, and how to structure the engagement.

UX Research

User Research Methods: The Complete Guide for 2026

The structured techniques for studying user needs and behavior, organized across three axes, with the core methods explained and a framework for choosing the right one.

Design Systems

What Is a Design System? A Complete 2026 Guide

A design system is the documented set of reusable tokens, components, patterns, and governance a team uses to build products consistently and fast. Here is how it works and how to build one.

Wireframing

Wireframing: What It Is and How to Do It Right

A wireframe is a low-detail layout that maps structure and flow before styling. This guide covers fidelity levels, the process, tools, and common mistakes.

Personas

User Personas: How to Create Research-Based Personas That Work

A practical guide to user personas covering the three types, the anatomy of a strong persona, and a research-based process for building personas teams actually use.

Information Architecture

Information Architecture in UX: The Complete Guide (2026)

A practical guide to information architecture in UX: what IA is, how it differs from navigation and sitemaps, its core components, research methods, and a step-by-step design process.

Journey Mapping

User Journey Map: The Complete 2026 Guide to Mapping User Experience

A practical guide to user journey mapping: what it is, how it differs from service blueprints and empathy maps, its anatomy, types, and a step-by-step build process.

Prototyping

Prototyping in UX Design: What a Prototype Is and How to Build One (2026)

A prototype is an interactive simulation you test before building. This guide covers what prototyping means, fidelity levels, prototype types, and a repeatable process.

Accessibility

Web Accessibility: A Practical Guide to Accessible Design in 2026

A direct, practical guide to web accessibility for designers and product teams, covering WCAG, the POUR principles, conformance levels, and how to test real interfaces.