All posts

Human-in-the-Loop AI Agents: When to Require Approval

Human-in-the-Loop AI Agents: When to Require Approval

Most approval policies get written the same way. Someone gets nervous, someone else says "just put a human in the loop," and every tool the agent can call starts asking for a click. Two weeks later the reviewers are approving forty prompts an hour without reading them. You haven't added a control. You've added a delay with a signature on it.

This guide covers the approval question only: which agent actions should run free, which should stop for a human, and which should never be enabled. It assumes you already have agents (or are about to put them in front of production systems) and that you own the call on what needs a sign-off. If you want the full governance walkthrough, start with how to govern AI agents in production infrastructure.

We'll use Luumen as the worked example, because it lets administrators set each tool to Full access, Ask for approval or Not enabled. By the end, you'll have a list of every action your agents can take, ranked by risk, a setting for every tool, approval requests that give reviewers enough context to decide, a plan for who approves what, and a way to spot approvals in your audit log that have become rubber stamps.

Step 1: List the actions, not the agents

Start with a list of what your agents do, broken down by action rather than by agent. "The patching agent" is not a unit you can write policy against. It reads package lists, restarts services, edits config files, reboots hosts and opens tickets. Those five actions share nothing when it comes to risk, and an approval rule that treats them as one will be either too loose or too noisy.

Write one row per action the agent can take against a real system. Use verbs and targets: "read journal logs on app servers," "restart nginx on a production web host," "update a ServiceNow incident," "run a package upgrade on a database host," "delete files under /var." If you can't name the target, you haven't found the action yet.

This is also why Luumen scopes permissions to the individual tool call rather than to the agent. The unit of decision is the call. Your inventory should match that unit, or you'll end up arguing about agents when the risk lives in a single command.

Here's a practical way to build the list: take the integrations and skills the agent already has, walk each one, and ask what the worst thing it can do is. Don't trust the tool's name. A tool called "manage service" might start, stop, enable and disable. Read the schema. Luumen treats each governed integration as a capability with a risk level, schemas, an approval floor and evidence requirements, reviewed before it is enabled. That review is the right moment to enumerate what each tool actually exposes.

Two rules for the inventory. Include actions that are technically possible but nobody intends the agent to use, since "nobody would ask it to do that" is not a control. And give multi-host fan-out its own row. One command against one server and the same command against forty are different actions.

Step 2: Score each action by reversibility and blast radius

Now give every row two scores. Keep them crude. Three levels each is plenty.

Reversibility: can you undo it, and how fast? Reading a log is trivially reversible because nothing changed. Restarting a stateless service is reversible in seconds. Editing a config file is reversible if you have the previous version and know it was changed. Dropping a table, rotating a credential, or rebooting a host mid-transaction may not be reversible at all. Be honest about "technically reversible." A restore from backup that takes six hours and loses a day of data is not reversible in the sense that matters at 3pm on a Tuesday.

Blast radius: how much breaks or gets exposed if this goes wrong? One non-production host is small. One production host behind a load balancer is medium. A shared database, an identity system, a network device carrying many services, or the same change across many servers is large. So is a read that returns credentials, personal data or regulated records, even though it changes nothing. If that output lands in a chat transcript, a read can be the riskiest thing an agent does.

Then use the two scores together. If an action is easy to undo and affects little, let the agent run it. If it's hard to undo or affects a lot, a human approves it first. If it's both, ask whether the agent should be able to do it at all.

Don't score by how scary the verb sounds. "Delete" on a temp directory is harmless. "Update" on a firewall rule can take down a site. Score the consequence, not the word.

When two reviewers score the same action differently, that disagreement is useful. Resolve it before you configure anything, and write down why.

Step 3: Map each tool to a setting

Scores only matter once they become a setting. Luumen gives administrators three per tool, and the mapping is mostly mechanical.

Full access means the tool runs without asking for approval. Use it for actions that are reversible and small: read-only queries, log inspection, listing and describing resources, status checks, ticket reads. If the worst outcome is a wasted second of compute, a prompt is pure cost.

Ask for approval means execution pauses for inline human-in-the-loop review inside the LuumenAI chat session. Use it for actions that change production state and are either hard to undo or wide in effect: service restarts on production hosts, package upgrades, config edits, anything that fans out across many servers, anything that writes to a system of record.

Not enabled means the tool is not available to the agent, whatever the prompt asked for. People underuse this setting. Credential rotation, destructive filesystem operations, user and permission changes on identity systems, and anything you'd want a change board and a maintenance window for regardless of who asks: switch it off.

This is stronger than an instruction in the prompt. Telling the model not to do something only works if the model listens. With Not enabled, the tool isn't there to call, so no prompt can get the agent to run it.

A useful sanity check: count your tools in each bucket. If almost everything landed in Ask for approval, your scoring was too cautious or your tools are too broad to separate the safe calls from the dangerous ones, so look at splitting them. If almost everything is Full access, go back to Step 2 and re-read your blast radius column.

Start tight and loosen with evidence. Moving a tool from Ask for approval to Full access after a month of clean, boring approvals is a decision you can defend. Going the other direction after an incident is not.

Step 4: Write the approval prompt a reviewer can judge

An approval gate is only as good as the information on it. If the reviewer sees "Agent wants to run a command. Approve?" they have two options: trust the agent blindly, or go investigate for ten minutes. They will pick the first one, repeatedly, and you'll have built a rubber stamp.

A reviewer needs to answer one question in under thirty seconds: should this run, here, now? Give them what that takes.

The exact action, not a summary. Show the command or call as it will execute, with parameters. "Restart service" is a summary. "systemctl restart nginx on prod-web-03" is an action.

The target and its scope. Which host or hosts, which environment, how many. If a single approval covers twelve servers, the prompt must say twelve and name them.

The reason. What the agent was asked to do and why this step follows, tied to the conversation. The reviewer should be able to see that a human asked for a patch run, and that this restart is part of it.

The risk level and what's reversible. A line saying this action is a production change and naming the rollback path changes how people read the prompt.

Luumen's design helps here. Approval is inline in the LuumenAI chat session, so the request sits next to the conversation that produced it, and each governed integration carries a risk level and evidence requirements the reviewer can lean on. Nobody forwards context to someone in another tool who has to reconstruct it.

Write your own standard for what an approvable request contains and check the real prompts against it. If a reviewer regularly has to ask "what does this do?" the prompt is under-specified. The reviewer isn't slow. Fix the prompt.

Step 5: Route approvals to the right person, with a safe timeout

Two questions decide whether approvals work in practice: who sees the request, and what happens if nobody does.

Who. The right reviewer is the person who would be accountable if the action went wrong, and who understands the target system. For an interactive session, that is often the engineer running the conversation, since the action is part of work they asked for and they can judge it in context. For higher-risk actions, it should be someone other than the requester. The classic failure is self-approval on everything: the person who typed the request clicks approve on the output of that request without a second thought. That's the same pair of eyes twice.

Split by risk. Routine production changes inside a patch window can go to the engineer on the session. Changes that touch shared infrastructure, identity or regulated systems should need a named second person or role. Use role-based access to make that a rule rather than a habit. Luumen backs governance with RBAC, so who can approve what is a configuration question, not a favor you hope people remember.

What happens on silence. Decide this in advance, and make the default safe. An unanswered approval should resolve to no action. Never design a timeout that proceeds on its own. If the request expires, the agent reports that it was not approved and stops, and a human can re-issue it when they're ready. A stale approval clicked an hour later, after conditions changed, is a hazard. Require the reviewer to confirm the request is still the one they think it is.

Luumen covers the other half of that risk. A run that pauses for approval doesn't keep the permissions it had when it stopped. When it resumes, Luumen checks its scope again against whatever is true at the moment the approver signs off. Permissions change and sessions end, so a request that sat overnight runs under this morning's rules, not last night's.

Also decide who covers when the usual reviewer is out. If approvals have only one possible recipient, you've built a single point of failure, and people will start looking for ways around it. Name a backup and test the handoff before you need it.

Step 6: Read the audit log for rubber-stamping

You set the policy. Now find out whether people are actually doing the reviewing. The evidence is in the audit log.

Luumen records every governed action in one queryable log: org, workspace, session, tool, risk, status, approval state and date. Approval state is the field to mine. It tells you which actions were approved, which were declined, and which ran under Full access with no gate at all.

Run these checks monthly, and after any incident.

Approval rate per tool. A tool approved 100% of the time over hundreds of requests is a candidate for Full access, because the gate adds nothing, or a sign the reviewers have stopped reading. Which one it is depends on the next check.

Time to approve. Sort approvals by how long they took. If production changes are being cleared in two seconds, nobody read them. Compare against how long the prompt takes to read honestly. A tight cluster of near-instant approvals is the signature of a reflex.

Declines. A healthy gate declines something now and then. Zero declines across a quarter on risky tools doesn't prove the agent is perfect. It more likely proves nobody is deciding.

Approval clustering. Look for the same approver clearing long runs of requests back to back, especially late in the day or in bursts. That's batch-clicking.

Risk against state. Filter for high-risk actions and confirm they sit where you expect: gated, or not enabled. A high-risk tool showing up under Full access is a policy bug to fix today.

When you find rubber-stamping, don't blame the people first. Ask why the gate exists for that tool. Then make the prompt more useful, move the tool to Full access if it's genuinely safe, or move it to Not enabled if it never should have been a click.

Troubleshooting: when approvals pile up or get ignored

Approvals pile up in a queue. Too many tools sit in Ask for approval. Go back to your scores and split broad tools so the safe calls (reads, lookups) can run under Full access while only the state-changing ones keep the gate. A queue means the setting is too broad. The reviewers aren't lazy.

Reviewers approve without reading. Look at the prompts first. If they don't show the exact action, the scope and the reason, the reviewer has nothing to judge, so fix the content (Step 4). Then check volume. People who see fifty prompts a day stop evaluating any of them. Cut the volume by moving low-risk tools to Full access, so the prompts that remain mean something.

Requests expire unseen. You probably have one reviewer and no backup, or approvals landing outside working hours. Add a named alternate, align gated work with the people who are on shift, and keep the timeout resolving to no action so a missed request fails safe.

People route around the gate. If engineers go back to running commands by hand because the agent is too slow, the gate is mis-set for that workflow. Find the specific tool causing friction and decide it on its score. Either it earns Full access, or it stays gated and you accept the cost for that action.

An action keeps getting declined. Stop re-approving and re-declining it. If reviewers keep refusing the same thing, that's a vote for Not enabled. Turn it off and remove the noise.

Nobody agrees on the scoring. Escalate the specific action to whoever owns the system, record the decision and the reason, and revisit it when something changes. Arguments about the abstract policy go nowhere. Arguments about one named action get settled.

Conclusion

Human-in-the-loop AI agents work when the gate is rare, specific and backed by a log you actually read. Run the safe stuff free, stop the consequential stuff for a person who can judge it, and switch off what a person should always do the long way. Then audit the approval state and let the numbers tell you which gates are earning their keep.

If you'd like to see this in action, book a demo. You'll see how Luumen scopes an agent's tools to Full access, Ask for approval or Not enabled, how the inline approval reads in LuumenAI chat, and how the audit log records the approval state of every governed action.

Frequently asked questions

Which AI agent actions should require human approval?
Actions that change production state and are hard to undo or wide in effect: service restarts, package upgrades, config edits, writes to systems of record, and anything fanning out across many servers. In Luumen, these map to "Ask for approval," while reversible reads can run under "Full access." Score each action by reversibility and blast radius first.
How do you stop approval prompts from becoming a rubber stamp?
Cut the volume and improve the content. Move genuinely safe tools to "Full access" so only meaningful prompts remain, and show the exact action, target, scope and reason on each one. Then check the audit log's approval state for near-instant approvals, zero declines and long single-approver runs.
What's the difference between "Ask for approval" and "Not enabled" in Luumen?
"Ask for approval" pauses execution for inline human review in the LuumenAI chat session, and the action runs if the reviewer approves. "Not enabled" means the tool isn't available to the agent at all, whatever the prompt asks. Use the second for actions a human should always handle through change control.
Should an unanswered approval request time out and proceed?
No. Design the timeout to resolve to no action, so a missed request fails safe and the agent reports it wasn't approved. Name a backup reviewer so requests have somewhere to go when the usual person is out, and require re-confirmation if an old request is approved late.
How can I check whether approvals are actually being reviewed?
Query the audit log. Luumen records org, workspace, session, tool, risk, status, approval state and date for every governed action. Look at per-tool approval rates, time to approve, decline counts and clustering by approver. Instant approvals on high-risk production changes are the clearest sign of a reflex rather than a review.

Start free today

Free for individuals — no credit card required. Upgrade when your team is ready.

Download Free
Share