Parloa LabsInsights

Failing with grace: error handling in AI agents

Anna Meck-Kerner

Senior Agent Architect @Parloa

This article is part of the Agent Architect's Digest, a series from Parloa's Agent Architects team.

Every conversation breaks down. People interrupt, mishear, misspeak, and ask each other to repeat themselves. Often, we barely notice because we’re good at repair: the linguist’s term for fixing trouble mid-conversation.

Between people, repair is often quick and informal. In their classic 1977 paper, Schegloff, Jefferson, and Sacks describe conversation as having a built-in repair system: a speaker can fix their own slip (“Tuesday, oh no wait, Thursday”), or the listener can flag a problem with anything from a glance or a “huh?” to a more targeted “Thursday, you mean?” Both partners can then continue the conversation without starting over or even noticing an error occurred.

With AI agents, misunderstandings can be harder to spot. On a call with another person, we might hear hesitation or uncertainty. Face to face, we have expressions and gestures to help us. These cues give us opportunities to notice trouble and intervene. An agent’s fluent response can leave us unaware that it has misunderstood.

Research on voice assistants shows why the design of repair matters. When Galbraith (2024) tested how Siri and Google Assistant responded to “huh?”, the most common response across the two assistants was to cancel the request. Yet users rated requests for clarification and acknowledgments of misunderstanding more favorably.

Those findings concern earlier voice assistants rather than large language model (LLM) agents, but they highlight an important design principle: how a system responds to misunderstanding matters to the people using it. Today’s LLM agents introduce different challenges, including errors that can look like successful responses.

For agent architects, good error handling means making trouble visible and helping the caller resolve it without starting over. That requires designing how an agent detects, communicates, and recovers from failure as carefully as how it handles a successful interaction.

What the NLU era taught us

Classic natural language understanding (NLU) systems, like earlier versions of Siri and Google Assistant, often failed in a recognizable way. They worked by matching what a person said to a set of predefined intents. When the speech recognizer produced a low-confidence transcript, or an intent classifier’s confidence fell below a threshold, a system would trigger a fallback, often phrased as: “Sorry, I didn’t understand. Please try again.”

But asking callers to repeat themselves could worsen the problem. Research on older speech recognition systems found that people often responded by hyperarticulating: speaking louder and slower, which could make their speech even harder for the recognizer to process (Hirschberg, Litman & Swerts, 2004).

When a fallback fired, failure was loud: the caller knew the system was having trouble. The system’s behavior was also bounded by predefined intents and workflows, although a confident misclassification could still send a conversation down the wrong path. Those limits didn’t guarantee successful repair, but they gave callers and designers explicit pointers at where to start a repair.

Why LLM errors are harder to catch

In an LLM agent, fluent language alone offers little indication that something has gone wrong. An agent can respond convincingly while acting on a mistaken interpretation or unreliable information. Explicit fallbacks can still be built into the system, but designers need signals that tell the agent when to use them. Two examples illustrate the challenge.

The first is a tool call that returns a plausible but wrong value. In “Loud Failures, Quiet Failures” (Kraishan, 2026), researchers injected faults into agents’ tool calls. Agents recognized the problem in 91.3% of trials when a tool returned an explicit error, but only 58.8% when it returned a plausible but wrong value. As we explored in our earlier piece on affordances, making the system’s state visible helps the agent choose a recovery action. Here, the user of that signal isn't the caller but the agent itself.

A second way errors can slip through unnoticed is ambiguity. Su and Cardie (2026) found that models can often recognize an ambiguous question when explicitly asked to judge it, yet still overwhelmingly answer ambiguous input directly. Where a person might ask, “Wait, did you mean Tuesday or Thursday?”, the agent often guesses and keeps going. The misunderstanding stays hidden and can't be repaired.

Silent failures make recovery harder, for callers and agents alike. If neither can tell that something has gone wrong, neither has a reason to initiate repair.

The design challenge extends beyond writing better fallback prompts to making failure states visible in the first place. Errors are built into conversation, so the question isn’t how to avoid them. It’s how an agent behaves right after one happens. Treat failure as design input, not something to hide.

So what does “good failure management” look like? Borrow what works in human conversation, and design for the ways machines fail differently.

Seven practices for failing gracefully

1. Know what failed, and say so. Distinguish between "I didn't catch that" (hearing), "I didn't understand that" (meaning) and "I couldn't complete that" (action). Each needs a different repair; one generic apology neither guides the caller nor moves the conversation forward.

2. Escalate repair gradually and context-sensitively. Mirror the human pattern. Start light (a short clarification request), get specific (a targeted question), then offer a way out. No single repair strategy works everywhere.

3. Repair locally. Don't restart the flow. Keep what was understood and ask only for what's missing.

4. Guide, don't blame. If the agent heard the policy number but couldn’t find a matching record, say: “I couldn’t find a policy with that number. Could you check it against the number at the top right of your letter?” This explains the problem and gives the caller a specific next step without assuming they made a mistake.

5. Never fabricate to fill a gap. An honest “I couldn’t retrieve your order status” is better than a confident invented answer that a caller might act on. Design tools to return explicit errors when a lookup fails, and validate consequential results before the agent reports success. When information remains unavailable or unreliable, the agent should explain the limitation and offer a next step, such as retrying the lookup or handing off to a human.

6. Ask when it matters; proceed when it doesn't. Asking slows the conversation down, but a wrong guess can do more damage. If a wrong assumption would have little impact and the action is easy to undo, proceed and make the assumption clear. If the consequences are significant or the action is difficult to reverse, ask first.

7. Plan the exit. Handoff to a human is a repair strategy, not a failure, especially when it carries context along.

People trust each other because we fix misunderstandings quickly and without blame. AI agents can earn the same trust, but only if they're designed to fail the way good conversational partners do: visibly, specifically, and with a clear way forward.

Sources

Schegloff, Jefferson & Sacks (1977), The preference for self-correction in the organization of repair in conversation, Language.

Galbraith (2024), An analysis of dialogue repair in virtual assistants, Frontiers in Robotics and AI.

Hirschberg, Litman & Swerts (2004), Prosodic and other cues to speech recognition failures, Speech Communication.

Kraishan (2026), Loud failures, quiet failures.

Su & Cardie (2026), Knowing but not showing.

Ready to turn conversations into lasting loyalty?

Let's build your next great customer experience.