Skip to content
UI/UX8 min read

AI Error Handling UX: How to Design for Incorrect or Incomplete AI Responses

How to design for AI errors: types of AI failure, graceful system failures, wrong and incomplete answers, clarification, retry and regeneration, correction, source inspection, fallback, escalation to people and recovering from incorrect actions.

01

Quick answer

Design AI features expecting four kinds of failure: system errors, wrong outputs, incomplete outputs and wrong actions. Preserve user input and offer retry and alternatives when systems fail; make wrong outputs detectable with sources, highlights and side-by-side verification; ask clarifying questions instead of guessing on ambiguous requests; let users edit, regenerate and select alternatives; prevent wrong actions with previews and confirmation, and recover from them with undo, clear change records and escalation to a person.

02

Where This Fits

The engineering side of failure handling, such as retries, fallbacks and circuit breakers, is in LLM application reliability. General patterns are in AI UX design and capturing corrections as feedback in AI feedback UX.

03

Error Types and Design Responses

Error typeExampleDesign response
System failureTimeout, provider outage, tool unavailableKeep input, explain, retry, degraded mode
Wrong outputIncorrect fact, misread requestSources, highlights, easy edit, report
Incomplete outputMissing fields, truncated answer, refusalShow what is missing, ask, continue
AmbiguityRequest could mean several thingsClarifying question with choices
Wrong actionUpdated the wrong recordPreview, confirm, undo, change log
04

Recovery Paths

05

Designing for Detectability

Users can only fix errors they notice. Make verification easy at the point of use: show extracted values next to the source document region, link claims to passages, highlight low-confidence fields, and show diffs for proposed changes. For high-stakes outputs, design review steps that require looking at the evidence. Automation bias, the tendency to accept automated outputs, is reduced when evidence is visible and checking is quick.

06

Clarification Instead of Guessing

When a request is ambiguous and the cost of a wrong guess is meaningful, ask. Good clarifying questions are short, offer likely options ('Do you mean the March invoice or the April one?') and remember the answer for the rest of the task. Do not ask when context makes the answer clear; unnecessary questions feel obstructive.

Users losing trust after AI mistakes?

ZSpace Labs designs detection, correction and recovery into AI features. See our UI/UX design services.

Start a Project
07

Retry, Regenerate and Correct

Offer regenerate with optional guidance ('more concise', 'use only the 2026 policy'), keep earlier versions accessible and preserve the original request. Let users edit outputs directly, and when they do, keep their edits rather than overwriting them on the next generation. Where a correction indicates a systematic problem, such as wrong data, capture it as feedback for the team.

08

System Failures and Degraded Modes

When the AI is unavailable or slow, the interface should never lose the user's input or freeze. Show a brief, honest message, offer retry, and provide a non-AI path where possible: manual entry, standard search results or contacting support. Design these states with engineering so they reflect real fallback behaviour; see LLM application reliability.

09

Recovering From Wrong Actions

Actions are where AI errors cost most. Prevent them with previews and confirmation; recover with undo, a clear record of what changed and guided steps for actions that cannot be undone, such as sent messages. Offer a fast route to a person for consequential mistakes, and log incidents so the team can find the cause.

10

Designing Refusals

Refusals are errors from the user's perspective when the request was legitimate. Keep refusals brief, explain scope rather than moralizing, suggest an alternative and avoid repeated refusals for similar safe requests. Track refusal rates and review samples to find over-refusal.

11

Advantages and Limitations

Designing for errors keeps users productive and trusting even when AI is imperfect, and it often matters more to adoption than small accuracy gains. It requires designing many additional states and close coordination with engineering on what failures look like. Prioritize the errors that are most frequent and most costly.

12

How to Design Error Handling Step by Step

  • 1. List likely errors from evaluation results and testing
  • 2. Rank them by frequency and cost
  • 3. Design detection: sources, highlights, previews
  • 4. Design recovery: clarify, retry, edit, fallback, escalate
  • 5. Preserve input in every failure state
  • 6. Add undo and change records for actions
  • 7. Capture corrections as feedback
13

Error Messages That Help

Good AI error messages say what happened in plain language, preserve the user's work and offer the next step. 'I couldn't find this in your policy documents. Try rephrasing, or ask HR directly' is better than 'Error'. Avoid blaming the user, avoid technical codes in the main message and avoid apologizing at length. Vary messages by cause: timeouts suggest retrying, missing data suggests uploading or rephrasing, out-of-scope requests suggest alternatives. Guidance on tone is in UX writing.

14

Learning From Errors

Every error state is a data point. Log which error states users hit, how often, what they did next and whether they succeeded. Frequent clarifying questions may mean the AI lacks context it could get automatically; frequent regenerations may signal poor default output; frequent escalations may reveal gaps in knowledge. Feed these patterns into prioritization and evaluation sets; see AI feedback UX and LLM observability.

15

Error States Checklist

  • Timeout or provider outage: input kept, retry offered, non-AI path available
  • No sources found: clear 'not found' state instead of a guess
  • Low confidence: uncertain parts highlighted, alternatives or a question offered
  • Partial output: what is missing is stated, with an option to continue
  • Refusal: brief reason, alternative suggestion, path to a person if relevant
  • Wrong action: undo or recovery steps, change record, contact option
  • Repeated failures: escalation with context
16

Worked Example

An illustrative scenario, not a client case: an expense app's receipt reader sometimes reads totals wrongly, and users discover this only when finance rejects claims. The redesign shows the receipt image beside extracted fields, highlights the total when the image is blurry, asks the user to confirm the total for amounts above a threshold and lets them correct it inline. Finance rejections for wrong totals drop.

17

Common Mistakes

  • Generic 'something went wrong' messages that lose input
  • Outputs that cannot be checked against sources
  • Guessing on ambiguous requests with costly outcomes
  • Regeneration that discards user edits
  • AI actions with no undo or change record

Want your AI error states reviewed?

Talk to ZSpace Labs about an AI error handling review across failures, wrong outputs and actions.

Start a Project
18

Agent Errors and the Recovery Loop

When AI agents act rather than only answer, new failure types appear alongside hallucinated and incorrect answers: a failed tool call, a timeout, a permission failure, a decision based on stale data, a partial completion (8 of 10 steps done) and the wrong action taken confidently. Each needs a visible state and a recovery path, not a generic error message.

A consistent loop helps users and teams: detect the problem (validation, monitoring, user report), explain it in plain language with what was and was not done, correct the input or data, retry safely with idempotency, undo what can be reversed and escalate to a person with full context when the agent cannot fix it. For making agent actions understandable in the first place, see AI agent trust UX; for reversal mechanics, AI agent rollback; for handing over to people, AI agent handoffs.

Error typeWhat the user should seeRecovery
Hallucinated answerClaim without a source flagged; sources shown where they existCorrect; regenerate with grounding; report
Incorrect answerEasy way to dispute or correctCorrect; feed back into evaluation
Failed toolWhich step failed and its effect on the taskRetry; alternative path; escalate
TimeoutTask still pending or unknown, not 'failed'Check state before retrying; never blind-retry payments
Permission failureWhat access is missing and who can grant itRequest access; hand off
Stale dataData age and what may have changedRefresh and re-check before acting
Partial completionWhat was done, what was not, what is pendingResume remaining steps; undo completed ones if needed
Wrong actionReceipt of the action and its effectUndo or compensate; notify affected people; escalate
AI error recovery loop (diagram)
detect ──▶ explain ──▶ correct ──▶ retry
   ▲                                   │
   │                          still failing / irreversible?
   │                                   ▼
   └────── learn (eval set) ◀── escalate ◀── undo / compensate
19

Conclusion

AI will be wrong sometimes; good design makes errors visible, cheap to fix and safe to recover from. Preserve input, show evidence, ask when unsure, support editing and undo, and keep a person within reach.

FAQ

Common questions.

System errors such as timeouts and outages; wrong outputs such as incorrect facts or misread intent; incomplete outputs such as missing information or refusals; and wrong actions such as changing the wrong record. Each needs different design.

Preserve the user's input, explain briefly, offer retry and an alternative path, and switch to a degraded mode if available, rather than showing a generic error or endless spinner.

Through sources they can check, highlighted uncertain parts, previews before actions and outputs designed for verification, such as showing extracted values next to the original document.

Yes, when a request is ambiguous and a wrong guess would be costly. Keep questions short, offer choices and avoid asking when the answer is obvious from context.

Retry or regenerate options that keep the original request, optionally with guidance such as 'shorter' or 'use the latest policy', and access to previous versions so users do not lose a better earlier answer.

By editing directly, selecting alternatives or telling the AI what was wrong, with corrections persisting and ideally feeding improvement.

Provide undo where possible, show exactly what changed, offer guided recovery and contact with a person, and log the event for investigation.

Briefly explain that the request is outside scope, suggest what the user can do instead and avoid lecturing. Track refusals to find legitimate requests being blocked.

Get in touch

Have a project in mind?

Whether you're building a new digital product, improving an existing website, or looking to automate part of your business — let's talk.