“Human in the loop” is the phrase everyone agrees on and few define. Done badly, it means a person rubber-stamping everything until they stop reading. Done well, it puts human judgement exactly where it’s needed and nowhere it isn’t. Here’s how we think about designing oversight that keeps agents safe without making them slow.
The trap: review everything
The instinct when deploying an agent is to make a human approve every action. It feels safe. In practice it creates a bottleneck that defeats the point of automation, and worse, it breeds rubber-stamping: when 99 of 100 actions are fine, the reviewer stops scrutinising and waves through the hundredth — the one that mattered. Oversight that’s applied everywhere is oversight that’s applied nowhere.
Match the checkpoint to the risk
The better approach is to vary the level of human involvement with the consequence of the action. We use a simple ladder:
Autonomous
Low-risk, reversible, high-volume actions run without review. Classifying a ticket, tagging a document, drafting an internal summary — let the agent do these freely and sample them later for quality.
Review-before-send
Actions that reach a customer or change a record get drafted by the agent and approved by a person. The agent does the heavy lifting; the human makes the final call. This is where most customer-facing agents should start.
Human-initiated only
High-consequence, hard-to-reverse actions — issuing refunds above a threshold, deleting data, sending contracts — are never taken autonomously. The agent can prepare them, but a person triggers them.
The question isn’t “should a human be involved?” It’s “involved in which actions, and how?” Spend your oversight budget where the consequences live.
Make review fast and informative
If you do ask a human to review, respect their time. A good review interface shows the proposed action, the reasoning and sources behind it, and a one-click way to approve, edit or reject. Reviewers who can see why an agent wants to do something catch the subtle errors; reviewers staring at a bare yes/no button don’t.
Use confidence to route
Not every case needs the same treatment. Agents can flag when they’re uncertain — an unfamiliar request, missing information, conflicting sources — and route just those cases to a human while handling the clear-cut ones autonomously. This concentrates human attention on the genuinely hard 5% instead of spreading it thinly across everything.
Design the escalation, not just the handoff
When an agent escalates, the human should receive context, not a cold start: a summary of the conversation, what the agent already tried, and what it thinks the options are. A handoff that dumps the problem back on a person with no context is slower than having no agent at all.
Close the loop with what you learn
Every human correction is a training signal. Capture edits and rejections, look for patterns, and feed them back into the agent’s instructions, retrieval or guardrails. Over time the agent should need less review for the cases it has seen, freeing human attention for new edge cases. Oversight should shrink as trust is earned — by design, not by fatigue.
What good looks like
- Routine, reversible actions run autonomously and are sampled for quality.
- Customer-facing and record-changing actions are reviewed before they take effect.
- High-consequence actions are always human-initiated.
- Reviews show reasoning and sources, and take seconds.
- Uncertain cases are routed to people; clear ones aren’t.
- Corrections feed back, so the need for review falls over time.
Get this right and you don’t have to choose between speed and safety. The agent handles the volume, your people handle the judgement, and the system gets quietly better every week. That’s the version of “human in the loop” worth building — and it’s how we build every agent. See our Security & governance approach for more.
