Human-in-the-Loop Is a Coaching Problem, Not a Gate

Published July 27, 2026

A Field Guide entry in “AI-Native Ways of Working.”

For a while, I insisted on being the bottleneck.

When I started building with agents, I wanted to be in on everything. I'd stand up a planner, an orchestrator, a couple of executor agents, and I'd approve every move. It felt responsible. Then one afternoon I looked up and I had fifteen chat windows open, copy-pasting context from one to another, trying to hold in my head who was waiting on what, what was in flight, and what was already done. I'd start ten things, step away, and come back with no idea where any of them stood. Mornings were the worst — I'd spend half a day just reconstructing the state I'd been in the night before.

Here's what finally landed: I wasn't reviewing the code anyway. I'm not an engineer. I was approving outputs I couldn't fully evaluate, and slowing the whole system down to do it. I'd made myself the single most expensive, least-scalable part of my own operation — and I'd racked up a pile of what I've come to call comprehension debt: work got done faster than I could understand what had been done.

That's when I stopped treating human-in-the-loop as a gate, and started treating it as coaching.

The gate is the problem

Most “human-in-the-loop” today is a gate: the agent does something, stops, and waits for a human to approve. It sounds safe. In practice it fails two ways, and both are bad:

• The rubber stamp. Nobody wants to read a wall of diff at 4pm, so the human clicks “approve” without really looking. You've kept the human in the loop on paper and removed them in reality — the worst of both worlds, with a signature on it.
• The bottleneck. Or the human takes it seriously, reviews everything, and becomes the throughput limiter — exactly where I was. The system moves only as fast as one tired person can read.

The flaw underneath both is an assumption: that autonomy is a switch — the agent either needs approval or it doesn't. That's not how you build trust with anyone. It's not how you delegate to people, and it shouldn't be how this works with agents.

The reframe: agents earn autonomy the way people do

When you coach a person or a team, you don't approve their every action forever. You start close, watch how they handle things, and hand over more rope as they earn it. You intervene by exception. You give feedback on outcomes, not keystrokes. Autonomy is something they develop — and your job is to keep moving them toward more of it, not to keep standing at the gate.

Apply that to agents and human-in-the-loop stops being a checkpoint and becomes a coaching relationship. The question is no longer “did the human approve this?” It's “where is this agent on its way to earning more autonomy, and where do I actually need to be?”

It's one ladder seen from two sides: each rung of autonomy the agent earns is a rung of altitude you gain — from doing the work, to reviewing it, to coaching it, to just setting intent. At the bottom, you're in the loop. Near the top, you're on the loop — steering the flow instead of standing in it.

How much autonomy? Two axes, not one

The common mistake is treating autonomy as a single dial. It's really a function of two things:

Axis 1 — Earned trust (per agent, over time). A brand-new agent starts with me fully in the loop. As it proves itself — as I watch it produce good outputs enough times — I ease off. Eventually it runs on “auto” and only pulls me in when it wants a decision. Trust is earned, and it gets pulled back when an agent starts duplicating another's work or shipping something half-finished.

Axis 2 — Blast radius (per action, fixed by risk). Independent of who's doing it, some actions carry more consequence. I think in tiers:

• Tier 1 — just do it. Small, low-risk, reversible. No ask.
• Tier 2 — do it, tell me, let me green-light. A little input, then proceed.
• Tier 3 — quick exchange first. A small decision, or a manual step I need to take.
• Tier 4 — a real conversation. Evaluate options, maybe a research spike, maybe I deploy or do something by hand.
• Tier 5 — fully human. Standing up infrastructure, anything irreversible, anything I have to own. We walk through it together.

Autonomy granted = earned-trust × blast-radius. High trust and low blast radius → full auto. Low trust or high blast radius → I'm engaged. A trusted agent still stops at Tier 5; a brand-new one gets watched even at Tier 1. That interaction — not a single on/off — is where the real design lives.

What the human actually does

Once you stop gating, the job changes shape:

• You move up the loop — from doing, to reviewing, to coaching, to just setting intent. (I borrowed this from David Marquet's intent-based leadership: the agent says “I intend to do X,” and I acknowledge or redirect on my own time. As trust grows, “I intend to” becomes “I did.”)
• You gate by exception — reserve your attention for the irreversible and the high-stakes; let the rest flow.
• You coach the outcome, not the code. This is my non-engineer's advantage, honestly. I don't tell an agent how to write it; I tell it what I want, look at what came out, and give feedback on that. The engineers I talk to often get more frustrated, because they try to steer the model down a narrow path keystroke by keystroke — and that style is going away.

Where this goes wrong (the anti-patterns)

Naming the failure modes is half the value:

• The Rubber Stamp — approving without reading.
• The Bottleneck — you in every loop.
• Automation Complacency — you stop checking what you should; the tests are green, but are they testing the right thing?
• Context Collapse — you're pulled in to judge something after you've lost the thread, so you can't judge it well.
• Escalation Fatigue — so many low-value “please review” pings that you start ignoring them, and miss the one that mattered.
• The Static Ladder — you grant autonomy once and never revisit it, up or down.

Where the metaphor breaks (because it does)

I won't pretend coaching an agent is the same as coaching a person. People bring baggage, self-sabotage, and history; change is genuinely hard for them, and much of coaching is about the human underneath the work. Agents have none of that. What they do have is a bottomless eagerness to agree and to tell you they've done the thing — which is why the whole model rests on trust but verify. “Coaching” an agent isn't a heart-to-heart; it's updating its instructions, clarifying its role file, removing contradictions, managing expectations.

There's a governance bonus hiding in here, and it matters if you're in a regulated shop like I used to be: when agents declare intent and you ratify it, you capture a cleaner audit trail than gate-stamping ever produced. But that only holds if you own the substrate underneath — the routing, the roles, the logging — so it survives the models changing out from under you.

For leaders

If you're rolling AI out across teams, the takeaway is this: the bottleneck isn't the human in the loop — it's the human stuck on the wrong rung. Your job is to keep moving people up the ladder as their agents earn trust — without overloading them, and without letting so much happen that nobody's steering. Get that calibration right and AI makes your people faster. Get it wrong in either direction — rubber stamp or bottleneck — and you've bought a very expensive way to feel in control.

This is one pattern from a larger set I'm working through on human-agent teams. It comes out of my own hands-on R&D — not a production deployment. I've been learning it by building it, breaking it, and coaching it back into shape.

Back to Field Notes