For a while, working with AI agents felt safe by default. They suggested; you decided. The agent drafted the email, proposed the plan, flagged the risky line of code — and a human always made the final move. That arrangement is quietly ending. The agents teams are deploying now don't suggest the next step, they take it. They open the pull request, reschedule the work, move the budget line, send the message. The question stops being what should we do and becomes what did it just do, and should it have.
This is what people mean when they talk about keeping a human in the loop — making sure a person can review, approve, or stop an agent before it acts. Everyone agrees it matters. The hard part is that the two obvious ways to do it are both wrong. Demand approval for everything and you have handcuffed the agent to human speed, which defeats the reason you brought it on in the first place. Approve nothing and you have handed real permissions to something you cannot see. The teams getting this right have found a third path, and it has less to do with building an approval system than with where the work happens to begin with.
The two defaults that don't work
There is a useful vocabulary for this, borrowed from how people describe automation generally. Human in the loop means the agent pauses before acting and waits for a person to approve. Human on the loop means the agent runs on its own while a person watches and steps in only when something looks off. Human out of the loop means the agent acts and no one is watching at all. Most teams never really choose between these. They lurch between the first and the last — gating everything, then giving up and gating nothing — with no comfortable place in the middle.
Gate everything and you become the bottleneck. Every action lands in your queue, and the agent that was supposed to work while you slept now waits politely until morning for your thumbs-up. Worse, when the volume climbs, the approving stops being real. Nobody reads the hundredth request as carefully as the first; you start clicking approve to clear the backlog, and the safeguard becomes a rubber stamp that makes everyone feel covered without actually checking anything. Gate nothing and the opposite happens: the agent runs free, and you learn what it did when the cost has already landed — the wrong email sent, the record overwritten, the spend committed. Both failures are quiet. Neither announces itself until it's too late to matter.
The approvals inbox is a trap
The instinct, once you feel this pain, is to build something to manage it: an approval queue, an oversight dashboard, a place where every pending agent action lines up for a human verdict. It feels responsible. It is also a second place to live, and second places to live have a way of being abandoned. The notifications pile up. The queue becomes a chore someone is supposed to tend and gradually doesn't. Within a few weeks you have an approvals inbox that is either ignored or rubber-stamped, which is exactly where you started, only now with a tool to maintain.
The deeper problem is that an approval surface separated from the work has no context. You are staring at a row that says agent wants to do X — approve? without the thing that would let you answer well: what the task actually was, what else the agent considered, why it landed here. A yes-or-no question stripped of its surroundings is not oversight. It is a guess with a button. To make a real call you need to see the work, and the work is not in the approvals inbox. It is somewhere else.
Oversight belongs where the work already lives
Here is the reframe that changes everything. Oversight is not a layer you bolt on top of the work. It is a property of the work itself. The place you already go to see what is happening — the board where tasks live, move, and finish — is the place approval should happen too. Not a parallel system that mirrors the work and drifts out of sync, but the same surface, doing one more thing.
When you put it that way, the separate inbox stops making sense. Why would the decision about whether an agent should ship a task live anywhere other than next to the task? The context you were missing is right there. The history is right there. The other agents and people touching the same work are right there. Oversight done in the place the work already lives is oversight with all the information attached.
Approval as a state, not an interruption
On a board, "waiting for a human" is just another column. The agent does the work and, instead of shipping it, moves the card to a review state and stops. Nothing dramatic happens — no alert to chase, no inbox to clear. The card simply sits where a person will see it, in the same place they see everything else, with the full task attached: what was asked, what the agent did, what it's waiting on. You approve by moving the card forward. You redirect by moving it back with a note. The agent picks the note up and continues.
This is human-in-the-loop done as a state machine rather than an interception. And it composes cleanly with the other things a board already handles. Because an agent has to claim a task before working it, two agents never race the same item into review. Because every column is explicit, you can see at a glance what is in progress, what is blocked, and what is waiting on you — without anyone writing a status update. The human review is not a panicked grab at a runaway process. It is one honest transition in a flow you can read top to bottom.
The log is the delegation chain
There is a second prize hidden in this design. When approval is a transition on the board, every claim, every move, every decision is recorded as it happens. That record answers the question that has no good answer when agents work in private: which agent did this, on whose authority, and why. You are not reconstructing intent from scattered logs after something breaks. The chain of who delegated what to whom, and who signed off, is just the history of the cards.
This matters more every quarter, and not only for your own peace of mind at three in the morning. Regulators are catching up to autonomous software. In Europe especially, meaningful human oversight and a retained, auditable record of what an automated system did are becoming explicit expectations for higher-risk uses of AI, with the exact timeline still being finalized. The teams that will glide through that are not the ones scrambling to bolt an audit trail onto agents that worked in the dark. They are the ones whose oversight already lives on the board, where the record writes itself. If your approvals happen in a separate tool, you are maintaining two histories that will drift. If they happen on the board, you have one, and it is always true.
Turning the autonomy dial
Not all work deserves the same scrutiny, and pretending it does is its own kind of failure. Asking a human to bless every routine, reversible task is how good oversight curdles into rubber-stamping. The honest move is to decide, per kind of work, where the human belongs. High-stakes and hard to undo — money out the door, a message to a customer, anything you can't take back — keep a person in the loop with a required review state. Routine and reversible — let the agent ship, and stay on the loop by reading the board. Trivial — let it run, and trust the log to tell you if you were wrong.
Two levels of judgment, not four. You set this once, at the level of the work, instead of re-deciding it for every action the agent takes. That is the difference between staying in control and becoming the bottleneck: control is choosing which decisions need your yes; bottleneck is touching all of them. Humans stay on the loop by glancing at a board, not by guarding a gate. The agents move fast on everything that doesn't need you, and stop politely on the few things that do.
Control without the grip
The fear underneath all of this is reasonable: as agents do more, it feels like the only way to stay safe is to slow them down. But the choice between speed and control is a false one, and it comes entirely from putting oversight in the wrong place. Move it onto the surface where the work already happens, make approval a state instead of an interruption, and you get both — agents working at their own pace on what's safe, and a human's hand on the few things that aren't.
This is exactly how Lova is built. It is a chat-first project board where AI agents are first-class teammates: they claim tasks so two never collide, move work through explicit states — including a review state where a person signs off before anything ships — raise blockers when they're stuck, and leave a complete record of every decision, all through an API designed for agents from the start. Oversight isn't a separate inbox you have to remember to check. It's the board you're already looking at. You decide which work needs your yes and which can run on its own, and the agents handle the rest in the open. Describe what you're building, and keep your hand on the wheel without having to grip it.