Loading
Blog

AI Agent UX Design: Approvals, Progress, and Error Recovery

Posted on  21 November, 2026 Last Updated 21 November, 2026
AI Agent UX Design: Approvals, Progress, and Error Recovery

AI agents are changing how people interact with software. Instead of navigating multiple screens and completing every step themselves, users can delegate goals and let an AI system work across connected tools. But when an agent starts making decisions and taking actions independently, a new design challenge emerges: how do users stay informed and in control?

A chat interface alone cannot answer that question. Users need to understand what an agent plans to do, which actions require permission, how far a task has progressed, and what happens when something fails.

Quick Answer: What is good AI agent UX design?

Good AI agent UX design gives users control over delegated tasks through clear execution plans, risk-based approvals, visible progress, and actionable recovery options. It helps users understand what an agent is doing, intervene when necessary, and verify the outcome without supervising every individual step.

What Is AI Agent UX Design?

 

AI agent UX design focuses on how people delegate, monitor, and control tasks performed by AI agents. Unlike traditional software, where users carry out most actions themselves, agents can plan tasks, use connected tools, observe results, and adjust their approach within defined permissions.

The distinction matters:

Design Dimension Traditional App UX Chatbot UX Agent UX
User input Clicks, forms and navigation Questions and prompts Goals and constraints
System behaviour Predetermined workflows Conversational responses Multi-step task execution
User’s role Performs actions Guides conversations Delegates and supervises
Main interface priority Navigation and usability Conversation clarity Visibility, control and recovery
Output Screens and records Text or generated content Results, completed actions and task updates

An AI agent may use one or several tools, operate in the background, or request information before proceeding. It does not necessarily need to be fully autonomous. Its level of independence depends on the task, permissions, and system design.

This makes agentic UX design less about creating another conversational interface and more about designing a complete experience around delegation and supervision.

How Do You Set Expectations Before an AI Agent Starts?

Users should understand what an agent is being asked to achieve, what it can access, and where its authority ends. A clear delegation experience prevents misunderstandings before they turn into execution errors.

Consider an enterprise user asking an agent to research five software vendors, compare them against company requirements, create a shortlist, and draft outreach emails to the top two.

Before starting, the interface should establish three things.

1. Define the goal, scope, and boundaries

A broad instruction such as “Find the best vendors and contact them” leaves too much room for interpretation.

The interface should help users specify:

  • Goal: Research five vendors and prepare a shortlist.
  • Criteria: Compare pricing, integrations, security, and support.
  • Resources: Identify which documents, websites, or systems the agent can access.
  • Constraints: Exclude vendors that do not meet mandatory requirements.
  • Restrictions: Draft emails but do not send them.
  • Expected output: A comparison report and two email drafts.

These details give the agent a clearer task and help users understand what they have delegated.

2. Show the proposed plan

Before execution, display the sequence of actions the agent intends to perform.

For example:

  1. Review the company’s vendor requirements.
  2. Search five vendor websites.
  3. Compare available product and pricing information.
  4. Prepare a shortlist with supporting sources.
  5. Draft two outreach emails.
  6. Pause for approval before sending anything.

Users should be able to edit the plan, change its scope, or cancel it. This is especially important when a task involves several connected applications or external actions.

3. Make permissions visible

Explain which systems the agent can access and which actions it can perform. Reading a document, editing a record, and sending an external email should not be treated as equivalent permissions.

Clear permission boundaries help users understand the agent’s capabilities without assuming that access to a tool automatically means authorization to perform every action within it.

When Should an AI Agent Ask for Approval?

An AI agent should request approval before actions that carry significant consequences, affect external systems or people, exceed granted permissions, or require a decision that should remain with the user.

Asking for approval at every step creates friction. Allowing unrestricted execution creates risk. The design challenge is to apply the right level of control to each action.

Distinguish between reversible and high-impact actions

Approval requirements should reflect the action’s potential impact and reversibility.

Action Example Recommended UX
Read-only Search vendor documentation Proceed within granted permissions
Preparation Draft a comparison report Show the result for review
Data modification Update a business record Apply scoped approval rules
External communication Send vendor emails Require explicit approval
High-impact action Delete production records Require strong confirmation and safeguards

A useful principle is to let agents handle routine, authorized work while placing meaningful checkpoints around consequential actions.

What should an approval screen show?

A generic “Are you sure?” dialog does not give users enough information to make a good decision.

An effective approval screen should explain:

  • Proposed action: What exactly will the agent do?
  • Scope: Which records, files, or recipients are affected?
  • Consequences: What will change after approval?
  • Evidence: What information supports the proposed action?
  • Reversibility: Can the change be undone?
  • Permission: What access or authorization is required?

For the vendor scenario, the approval card should display the two email recipients, message previews, and sending accounts. The user should be able to edit, approve, or decline each message.

Use specific action labels such as “Send these two emails” instead of vague buttons such as “Continue”.

How can designers prevent approval fatigue?

Repeated approval requests can interrupt work and encourage users to approve without reviewing. Human-in-the-loop UX should therefore be based on risk and context, not on the number of steps in a workflow.

Designers can reduce unnecessary interruptions through:

  • Granular permissions for reading, editing, and external actions.
  • Scoped approvals for clearly defined tasks.
  • Batch approvals when several actions have similar consequences.
  • Editable plans that users can review before execution.
  • Fresh confirmation when important details change.

An approval must apply to the action the user actually reviewed. If the recipients, amounts, records, or other consequential details change, the interface should request renewed authorization.

How Should the Interface Show Progress and Recover from Errors?

A reliable agent experience makes execution visible and treats failure as a normal system state. Users should know what has happened, what is happening now, and what they can do next.

1. Show meaningful progress, not just loading indicators

A generic “Thinking…” message provides little information during a long-running task. A progress interface should communicate verified actions and current task status.

Useful states include:

Agent State What the User Should See
Planned The agent has prepared its task sequence
In Progress The current action and completed steps
Waiting for Approval The action requiring user authorization
Blocked The issue preventing further execution
Partially Completed Completed work and outstanding steps
Completed Verified outcome and task summary
Failed What could not be completed and available recovery options

Prefer concrete milestones such as “Reviewed 3 of 5 vendors” over arbitrary percentages. A percentage suggests measurable progress, so it should only appear when the system can calculate it meaningfully.

2. Maintain a persistent activity history

AI agents may continue working after a user leaves the current screen. The interface should make it possible to return and understand the latest task state without starting again.

A persistent status panel or activity history should show:

  • Current task status and last update.
  • Actions already completed.
  • Tools or systems accessed.
  • Pending approvals and unresolved blockers.
  • Relevant changes made by the agent.
  • Available pause, resume, and stop controls.

These controls must have distinct meanings. Closing a panel should not unexpectedly stop a background task. Pausing should suspend further execution, while stopping should clearly explain what happens to actions already completed.

3. Preserve partial results when a task fails

A single failed step should not automatically erase successful work.

For example, suppose the agent reviews four of five vendors but cannot access the final vendor’s pricing page. It should retain the four completed reviews, identify the missing information, and explain what the user can do next.

Useful recovery options might include:

  • Retry the unavailable source.
  • Provide another website or document.
  • Continue with the available information.
  • Pause the task until access is restored.

This approach makes partial completion visible rather than presenting an entire workflow as unsuccessful.

4. Differentiate between temporary and persistent errors

Not every failure requires the same response.

  • Transient errors include temporary network interruptions, rate limits, and unavailable services. The system can attempt a bounded retry, communicate the delay, and show the retry status.
  • Persistent or action-blocking errors include missing files, invalid credentials, restricted permissions, and unsupported actions. The agent should stop the affected step, explain the problem, and ask for the information or access needed to continue.

Repeatedly retrying an action that requires new credentials or user input does not improve the experience. It only leaves users waiting.

5. Make error messages actionable

An effective AI agent error handling experience answers three questions:

  1. What went wrong?
  2. Which part of the task was affected?
  3. What should happen next?

For example:

Generic message: “Operation failed. Error 500.”

Useful message: “The fifth vendor’s pricing page could not be accessed. Four vendor reviews are complete. You can retry the source, provide another link, or continue with the available results.”

The second message identifies the issue, preserves context, and gives the user a decision.

6. Provide safe recovery and human handoffs

Depending on the failure, the interface should offer the appropriate recovery path:

  • Retry: Attempt a failed step again when the issue is temporary.
  • Modify: Correct the input or change task parameters.
  • Use an alternative: Switch to another permitted tool or source.
  • Clarify: Ask the user for missing information.
  • Undo or rollback: Reverse changes when the system genuinely supports it.
  • Take over: Let the user complete the blocked step manually.

A particularly important case occurs when an external request times out after it may already have been submitted. For example, an email service might receive a message but fail to return confirmation.

A “Retry All” button could send the same email twice. The safer design is to check the external system’s current status first, reconcile the result, and retry only when the original action is confirmed not to have occurred.

Recovery should preserve completed work and make the next action explicit.

How Do You Test Whether People Can Supervise an AI Agent?

Testing should evaluate more than whether an agent completes a task successfully. It should establish whether users understand its actions, recognize risks, and recover when execution does not go as planned.

Test the entire task journey

Use realistic scenarios to check whether users can:

  • Understand and edit the proposed task plan.
  • Identify actions that require approval.
  • Explain what they are authorizing.
  • Find completed steps and current status.
  • Pause or stop execution correctly.
  • Recover from a failed action.
  • Resume without repeating completed work.
  • Verify whether an external action actually occurred.

Include interrupted workflows, permission failures, and uncertain outcomes. Testing only the successful path leaves important design problems undiscovered.

Which metrics should product teams track?

Useful measures include:

Metric What It Reveals
Task completion rate Whether delegated tasks reach their intended outcome
Approval comprehension Whether users understand what they approve
Unintended-action rate Whether the agent acts outside user expectations
Recovery success rate Whether users can resolve failures
Time to recovery How quickly users return to a workable state
Unnecessary interruption rate Whether approval requests create avoidable friction
Human handoff resolution Whether users can successfully take over blocked tasks

Interpret these measures together. Fewer approval requests, for example, are not necessarily an improvement if unintended actions increase.

Design the Controls Before Scaling the Automation

An AI agent becomes useful when users can delegate work without losing control of its execution. Clear task plans, meaningful approval checkpoints, observable progress, and reliable recovery paths make that possible.

For product teams, the priority is not simply to increase agent autonomy. It is to design the right level of autonomy for each task and give users the information and controls to supervise it.

Planning an AI-powered product experience? Discuss your project with Lollypop.

Frequently Asked Questions

1. How is AI agent UX different from chatbot UX?

Chatbot UX focuses primarily on conversations and responses. AI agent UX also needs to support task delegation, multi-step execution, connected tools, approval decisions, background progress and error recovery.

2. When should an AI agent ask for human approval?

An agent should request approval when an action has significant consequences, affects external systems or people, exceeds granted permissions, or requires explicit user consent. The approval should explain the action and its impact.

3. How do you show progress in a long-running AI agent workflow?

Use visible task states, completed milestones, current activity, pending approvals, and blockers. Provide a persistent activity history so users can return later and understand what happened. Use completion percentages only when they reflect measurable progress.

4. Can an AI agent undo an action after an error?

Only when the system supports reversal for that action. Some changes can be rolled back using saved states or undo operations, while external actions such as sent emails or completed payments may not be reversible. The interface should explain these limitations before execution.

Image