Escalation to Human
Every agent eventually meets a decision it should not make. The refund is larger than policy allows, the request is ambiguous in a way no tool can resolve, the same step has failed four times. Escalation to human is the designed exit for exactly those moments: the agent stops, hands the task to a person, and brings the context with it.
What a good escalation carries
The hand-off is a deliverable, not an error message:
- a clear trigger — low confidence, a policy boundary, repeated failure, a missing permission, or an explicit request for a person;
- the trajectory so far: what was attempted, what the tools returned, what the agent concluded;
- a proposed next action, so the human reviews a draft instead of starting cold;
- a route back, if the human's answer lets the agent resume.
Why it is not an approval gate
An approval gate keeps ownership with the agent: it pauses, a person confirms, it continues. Escalation transfers ownership — the agent is finished, and the measure of the system becomes how often it needs this. Customer-support deployments track exactly that as a containment rate and treat a clean escalation as a success. The alternative is worse than it sounds: an agent with no escalation path does not stop at the edge of its competence, it guesses — inventing a policy, choosing an interpretation, or looping until its step budget runs out, with nobody aware that a judgement call was made on their behalf.
Escalation to human is the designed hand-off in which an agent stops work and transfers a task to a person — triggered by low confidence, an ambiguous request, a policy boundary, or repeated failure — passing its trajectory and a proposed action along with it. Unlike an approval gate, ownership moves to the human. Without this exit an agent guesses at the edge of its competence instead of stopping, and nobody learns it did.
A good front-desk clerk handles most of what comes at them and knows the exact moment to say: let me get my manager. Escalation to human is that instinct, built into software.
When a program is working on its own, it runs into things it should not decide alone — a request that is unclear, an amount that is unusually large, or a step that keeps failing. Rather than guess, it stops and hands the job to a person, along with a note on what it already tried. This is not a breakdown; it is the feature that makes the whole arrangement trustworthy. Software that never asks for help does not become more capable — it just makes its mistakes quietly.