AWS Builder Center

Your Agent Handles Everything. Should It?

Your agent passes every eval, stays on budget, and runs clean, right up until the Tuesday it approves something it should have flagged, with total confidence and no one asked. The mark of a production-ready agent is not how much it handles alone, but whether it knows when to stop and escalate. Covers the escalation decision boundary, the four ways human-in-the-loop quietly fails, and how to build it on AWS with Step Functions task tokens, approval tools, and safe timeouts.

Senior Manager - Industrial AI - Accenture Solutions Pvt Ltd
Your agent passes every eval, stays inside budget, and runs clean in production. Then one Tuesday it approves a loan it should have flagged, or overrides a setpoint on a line it half understood, and it does it with total confidence and zero hesitation. Nobody was asked. Nobody signed off. The system did exactly what you built it to do: handle everything.
That is the problem.
Across this series I have argued that agents die in the last mile, not the demo. Human-in-the-loop is where that argument gets concrete. The skill that separates a production agent from a science project is not how much it can do on its own. It is whether it knows when to stop and ask.

Autonomy is not the goal

We talk about agents as if more autonomy is always better, as if the finish line is an agent that needs no one. In a regulated or industrial setting, that framing is backwards. A retail lending compliance check, a maintenance action on a running asset, a customer refund above a threshold: the cost of one confidently wrong autonomous action dwarfs the cost of a human glance. Full autonomy is not a feature there. It is unpriced risk.
The goal is calibrated escalation. An agent that handles the routine 95% cleanly and hands you the 5% that actually needs judgment is worth far more than one that handles 100% and quietly gets a few of them badly wrong. The second one looks more impressive in a demo and is far more dangerous in production.

When should an agent escalate?

Escalation is a decision boundary, and most teams never define it explicitly. They bolt on a human review step at the end and call it a day. Draw the boundary on purpose instead. An agent should raise its hand when any of these are true:
  • Low confidence. Retrieval came back thin, the judge score is weak, or the model itself signals uncertainty. If grounding is poor, that is a stop signal, not a reason to guess.
  • High blast radius. The action is expensive, irreversible, or touches money, safety, or a customer of record. Reading data is cheap. Committing a change is not.
  • Policy or compliance trigger. The request crosses a rule you have written down: a loan above a limit, a data category that needs consent, an action a regulator cares about.
  • Novelty. The situation does not match anything the agent has seen work before. Out-of-distribution is exactly when overconfident models fail.
  • Conflicting evidence. Two retrieved sources disagree, or the tool result contradicts the plan. A human resolves ambiguity better than a temperature-zero guess.
Notice that confidence alone is not enough. A high-confidence action with a large blast radius should still route to a human, because confidence and correctness are not the same thing, and you have all read the transcripts where they came apart.

The four ways human-in-the-loop goes wrong

Adding a human is not the same as adding the right human at the right moment. Four failure modes show up again and again.
It escalates everything. Every action pings a reviewer. Within a week the reviewers are rubber-stamping without reading, and you have built alert fatigue with extra steps. An escalation that always fires is noise, and noise gets ignored.
It escalates nothing. The path exists in the diagram but never triggers, because the thresholds were set to keep throughput high. This is the silent, confidently-wrong failure, and it is the one that ends up in an incident review.
It escalates too late. The human is asked to approve after the irreversible thing already happened. A human-in-the-loop that reviews the receipt is not a control. It is a paper trail for the postmortem.
It escalates to nowhere. The request goes to a shared inbox or a channel no one owns. No timeout, no fallback, no accountability. The agent waits, the task rots, and eventually someone force-completes it just to clear the queue.
If you only remember one thing: an escalation is only real if a specific human owns it, it fires before the point of no return, and there is a defined answer for what happens when no one responds.

Building it on AWS

The good news is that "pause, wait for a human, then resume" is a solved orchestration problem on AWS. You do not need to invent it.
Gate actions by blast radius, not by default. Split your tools into read and commit. Reads run freely. Commits with real impact route through an approval gate. Bedrock Agents and AgentCore let you model this cleanly: give the agent an explicit request_approval tool so that asking for a human is a first-class action the model can choose, not an error it falls into.
Use Step Functions with the task token pattern for the pause. The waitForTaskToken integration is built for exactly this. The workflow reaches a human-approval state, emits a token, and suspends without burning compute while it waits. A reviewer approves or rejects, your callback returns the token, and the state machine resumes on the right branch. This is the canonical AWS way to hold a workflow open for human judgment, and it survives restarts far better than a process sleeping in memory.
Route the escalation to a person, not a void. Push the request to a reviewer through SNS or an SQS review queue, surface it in Slack or Teams, or use Amazon Augmented AI when you want a managed review UI and a structured verdict. The point is that a named human, or a named role, is on the hook.
Always define the timeout and the fallback. Decide what happens when no one answers in N minutes. The safe default in almost every high-stakes setting is to hold, not to act. An agent that proceeds on silence has no human-in-the-loop at all. It has a human-shaped delay.
Log the handoff like any other action. Who was asked, what context they saw, what they decided, and when. This ties straight back to the observability piece earlier in the series. An approval you cannot audit is not a control you can defend.

Design the handoff, not just the trigger

The part teams skip is the context transfer. When your agent escalates, what does the human actually see? A reviewer handed a raw prompt and a yes/no button cannot add judgment. They can only add latency. Hand over the decision that is pending, the evidence the agent gathered, the specific reason it stopped, and the reversible and irreversible options on the table. Design the return path too: when the human decides, the agent should resume with that decision folded into its state, not start over and re-derive its way back to the same fork.
Escalation is a first-class capability, not an exception handler. Build it that way and the human becomes part of the loop by design. Bolt it on at the end and the human becomes the thing everyone routes around to hit their numbers.

The through-line

You can prove your agent works with an eval harness. You can afford it with cost control. You can watch it with observability, and you can trust its memory with real context engineering. But if it cannot recognize the moment it is out of its depth and raise its hand, none of that saves you on the Tuesday it matters. The most production-ready thing an agent can do is know the edge of its own competence, and stop there.
An agent that handles everything is not the win. An agent that knows what not to handle is.


If this was useful, the earlier parts cover evaluation harnesses, token economics, observability, and memory and context engineering for production agents on AWS.
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article