Every conversation about AI agents eventually reaches the same sentence: "and if it can't handle it, a human takes over." That sentence usually covers a design gap the size of the project. The handover is not the fallback. It is the part of the system that determines whether the automation is safe to run at all.
An agent that does ninety percent of the work and hands over badly is often worse than no agent. The person inherits a half-finished task with no history, the customer repeats themselves, and the team learns to distrust the whole thing. The escalation path deserves the same design attention as the happy path, and it rarely gets it.
Decide what the agent is allowed to finish
Before you can define an escalation, you need a boundary. Write down three categories for every workflow the agent touches:
- Handled. The agent completes the task and informs a person afterwards, or not at all.
- Proposed. The agent prepares the action (the draft reply, the refund, the record change), and a person approves it before it takes effect.
- Escalated. The agent does not attempt the task. It gathers context and routes it.
Most teams only write the first category down. The other two get decided implicitly, in code, by whoever implemented the error branch.
The boundary should follow consequence, not difficulty. An agent can be perfectly capable of issuing a refund and still not be allowed to, because the action is irreversible and the error is visible to a customer. Conversely, a technically awkward task with a cheap undo is a fine candidate for full automation.
Ask what happens if this step is wrong and nobody notices for a week. If the answer is uncomfortable, the step belongs in the proposed or escalated category regardless of how well the agent performs it in testing.
The triggers that actually matter
Confidence thresholds are the trigger everyone implements first and the one that carries the least weight on its own. A model's self-reported confidence is not well calibrated, and an agent can be entirely confident about a conclusion drawn from the wrong document.
A production agent should escalate on a combination of signals:
| Trigger | Example |
|---|---|
| Low retrieval support | No approved source matched the question above the relevance floor |
| Conflicting sources | Two approved documents give different answers to the same question |
| Out of scope | The request is about a topic the agent was never given material for |
| Irreversible action | Payment, cancellation, data deletion, anything sent to a third party |
| Threshold breach | A value above an agreed limit (a refund amount, a discount, a date change) |
| Repeat contact | The same person on the same issue for the second or third time |
| Sentiment or risk language | Distress, legal threat, regulator mention, safety concern |
| Identity uncertainty | The agent cannot confirm it is speaking to the account holder |
| Tool failure | An integration returned an error the agent cannot interpret |
Several of these have nothing to do with the model's ability. They are policy decisions, and they should live in configuration where an operations lead can read and change them, not buried in a prompt.
Repeat contact deserves its own rule
A second message about the same issue is the clearest signal in the list and the most frequently ignored. Whatever the agent said the first time did not work. Trying again with the same material produces the same answer in different words, which is how a mildly annoyed person becomes a complaint. Route the second contact to a person by default.
A handover is a package, not a ping
The difference between an escalation that helps and one that just relocates the problem is what travels with it. A usable handover contains:
- The request as the user wrote it. Not the agent's paraphrase. The original words carry information the summary loses.
- What the agent already did. Lookups performed, records read, actions taken, messages sent. The person must not repeat a step or contradict one.
- The sources consulted. Links to the actual documents and sections, so the person can confirm or correct in seconds.
- Why it stopped. A specific reason code, not "could not complete."
conflicting_sources,amount_over_threshold,identity_unconfirmed. - The identifiers it is holding. Order number, account ID, ticket reference, conversation link.
- A proposed next action. Even when the agent may not execute, it can usually recommend. A person accepting or editing a draft is far faster than a person starting blank.
The user-facing half matters too. "I'm passing this to a specialist, they have everything we've discussed and will reply by tomorrow morning" sets a real expectation. "I'm unable to help with that" ends the conversation and starts a second one somewhere else.
Route to a role, not a person
Escalations should land on a queue owned by a role, with an agreed response window and a defined fallback when nobody picks it up. Routing to an individual produces a system that quietly stops working when that person is on leave.
Define, in writing:
- Which queue receives which reason codes.
- The target response time per queue, and whether it differs by hour or day.
- What happens when the target is missed, a second alert, a manager, a different queue.
- Who can override the agent's decision, and whether that override is recorded.
- Who closes the loop with the original requester.
An escalation that nobody owns is an unhandled exception with a friendlier label.
Build the return path
Most designs route work outward and never bring anything back. That is a missed opportunity, because the person resolving the escalation is producing exactly the data the system needs.
Make the resolution structured:
- The human records what the correct outcome was, from a short list where possible.
- The reason code is confirmed or corrected.
- Anything that should have been in the knowledge base is flagged for the content owner.
- The conversation is attached to the record so the next contact has history.
Then review the reason codes on a fixed cadence. Each recurring reason has exactly three possible responses: fix the source material, expand what the agent is permitted to do, or accept it as a permanent human case and resource it. Reviewing nothing is how an escalation rate of five percent becomes twenty-five percent over a year without anyone deciding it should.
Watch the queue like a queue
An escalation path is an operational system and needs operational metrics:
- Escalation rate, overall and per reason code.
- Time to first human response, not time to resolution.
- Resolution outcome, was the agent right to stop?
- False escalations, where the agent could safely have continued.
- Missed escalations, where it continued and should not have.
The last two are the ones that tell you whether the thresholds are set correctly. A system with zero false escalations is almost certainly too permissive somewhere. A system where most escalations resolve as "agent was right, nothing more needed" has thresholds that are too tight and is burning human attention to produce no change in outcome.
Instrument this from the first day of the pilot, because the first weeks are when the thresholds are worth the most and the data is cheapest to collect.
A short design checklist
Before an agent goes live on real traffic, you should be able to answer each of these without discussion:
- What are the three categories (handled, proposed, escalated) for this workflow?
- What are the triggers, and where does an operations lead change them?
- What exactly is in the handover payload?
- Which queue receives it, with what response target?
- What does the user see and hear when it happens?
- How does the resolution come back into the system?
- Which five numbers tell us this is working, and who looks at them?
If any answer is "we'll see how it goes," the agent is not ready for production traffic. It is ready for a supervised pilot, which is a different and much safer thing to launch.
The point of an escalation path is not to catch the agent's mistakes. It is to make the boundary of the agent's authority explicit, so that everyone (the team, the customer and the system itself) knows where it ends.
If you are designing an agent that touches customers or money, see how we scope production AI systems or book a strategy call to map the boundary before the build starts.