Watch someone use an agent that asks for approval on everything, and you will see the same thing every time. By the third prompt they have stopped reading. By the tenth they are clicking Approve as a reflex, eyes already on the next thing. The gate is still there. The oversight is gone. We built a button and called it safety.
This is the dirty secret of human-in-the-loop. Most of it is theater. The approval step exists so that when something goes wrong, there is a human to point at. It does not exist because the human was actually exercising judgment. A gate that fires constantly does not produce oversight. It produces a trained yes-machine made of a person.
Approval fatigue is a real, measurable failure
The psychology here is not subtle. If an interface asks you to approve a stream of actions that are 98% fine, you will learn, correctly and rationally, that approving is almost always the right move. Your brain optimizes. It stops spending attention on a check that almost never matters. And then the 2% case, the one the whole gate existed for, sails through on the same reflex as everything else.
I watched this happen on an early version of a content-and-outreach agent. It drafted messages and asked for approval before sending each one. The operator approved 40 a day. The drafts were good, so approval became automatic. When the agent eventually drafted one that addressed a prospect by the wrong company name, it went out, because it looked like all the others at a glance and the human had long since stopped actually reading. The gate had a 100% approval rate. That is not a safety mechanism. That is a latency tax.
An approval gate with a 99% yes rate is not oversight. It is a slow autopilot with a human-shaped delay built in.
The fix is fewer gates, not more
The instinct when an agent does something bad is to add an approval step. It is almost always wrong. Adding gates dilutes attention across all of them, which makes every gate weaker, including the ones that mattered. The move is the opposite: ruthlessly remove gates so that the ones that remain are rare enough to still command attention.
The filter I use is the same magnitude-and-reversibility test that governs the rest of my autonomy work. An action earns a human gate only if it is both consequential and hard to undo. Run every action through two questions:
- Is it reversible? If yes, it almost never needs a gate. Let the agent act, log it, and make the human’s job reviewing and reversing rather than pre-approving. Catching and undoing a reversible mistake after the fact costs less attention than pre-approving a thousand fine actions to prevent it.
- Is it consequential? If an action is irreversible but trivial, automate it inside a tight envelope. If it is irreversible and consequential, that is the action that deserves a human, and now the human has the attention to spend because you stopped wasting it on everything else.
| Action | Reversible? | Consequential? | Treatment |
|---|---|---|---|
| Draft an email | yes | yes | No gate; agent drafts, human edits |
| Send a routine reminder | yes (recall window) | low | No gate; review after |
| Apply a small credit | yes (ledger) | medium | No gate; daily digest |
| Issue a cash refund | no | yes | Hard gate, full context |
| Delete customer data | barely | severe | Hard gate, two-person |
Most of the table is “no gate.” That is the point. Spend the human’s scarce attention only on the bottom two rows.
A real gate gives the human something to actually judge
When a gate does fire, it has to be worth a human’s full attention, which means it cannot be a yes/no popup with no information. The single biggest reason approvals become rubber stamps is that the interface gives the human nothing to reason about. “Approve this refund? [Yes] [No]” is not a decision. It is a dare.
A real gate surfaces what a competent human would need to actually decide:
- What the agent wants to do, in plain terms. Issue a $4,000 refund to this customer against this invoice.
- Why. The reasoning trace that led here, summarized, including the specific evidence the agent is relying on.
- What is unusual about it. This refund is 8x larger than the median refund this agent has proposed. That one line does more for real oversight than any amount of formatting.
- The reversal path. What happens if you approve and it was wrong, and what it costs to undo.
The “what is unusual” line is the highest-leverage thing in the whole gate. Humans are bad at scanning for problems in a stream of normal-looking items and good at reacting to a flagged anomaly. So the system, not the human, should do the anomaly detection, and the gate should lead with it. The agent already knows this refund is an outlier. Make it say so.
Asynchronous and batched beats synchronous and constant
Synchronous approval, where the agent stops and waits for a human before every consequential step, scales terribly and is exactly what produces fatigue. Two patterns serve far better.
The first is propose-and-batch. The agent does its reversible work autonomously and accumulates the consequential proposals. Once a day, or once a threshold is crossed, a human reviews the batch with full context, in a single focused sitting, rather than being interrupted forty times. Concentrated attention on a small batch beats diluted attention across a constant stream.
The second is act-then-review with a reversal window. For actions that are reversible but you still want a human in the picture, let the agent act, then put it in a review queue with a window during which a human can pull it back. The agent gets to move at machine speed; the human gets a real, attention-worthy checkpoint where the items are pre-filtered to the ones worth looking at. This only works because the action is reversible and the trajectory is logged, which is why durability and replay are prerequisites, not afterthoughts, for honest human-in-the-loop.
Oversight is a budget, so spend it
The reframing that fixed this for me: human attention is a fixed, small budget, and every gate is a withdrawal. Spread it across a hundred trivial approvals and you have funded none of them. Concentrate it on the three actions a week that are genuinely irreversible and consequential, and each of those gets a human who is actually awake.
The agents I run in production ask for approval rarely. When they do, the human stops, because they have learned that a gate from this system means something. That learned weight is the entire asset. It is built by saying no to almost every gate someone wants to add, so that the few that survive still have the power to make a person pause and read. This is the approval model I’m building into Vontra: the system decides what’s worth a human, not the human deciding what’s worth ignoring.
Human-in-the-loop is not a checkbox you add to make an agent safe. It is a scarce resource you protect, by automating everything that does not need it, so that the human’s judgment is available, intact, on the day the system finally needs it.