Gouvernance

Where to Put Human Approval in AI Agent Workflows

· founder of ETCSEC · updated November 17, 2026 · 9 min
Illustration of a robot pausing at a review checkpoint before a blocked action.
The short answer

Put the human approval gate on high-impact AI agent actions only, enforced outside the agent itself, never inside a prompt it controls. Before deciding who approves what remains, shrink what the agent can do in the first place, then log who authorised each approved action, especially the ones that cannot be undone.

Approving everything makes agents pointless; approving nothing is a liability

A CTO rolling out AI agents usually lands on one of two failure modes. Require approval for every action and the agents stop saving any time, since someone still has to click through each step by hand. Require approval for none and a single bad tool call, a wrong file deleted, a message sent to the wrong customer, a merge that skips review, becomes the agent's problem to explain after the fact, not before. Neither extreme is a policy; both are an admission that nobody decided where the gate should sit.

OWASP's GenAI Security Project names the underlying problem Excessive Agency: damaging actions performed in response to unexpected, ambiguous, or manipulated model output, rooted in excessive functionality, excessive permissions, or excessive autonomy granted to the agent. The fix OWASP describes is not a blanket approval screen in front of every action; it is reducing what can go wrong first, then gating only what is left.

The two failure modes described above are not hypothetical for agents connected through MCP, the protocol most of these tools use to reach real systems. The same approval question, should this specific call wait for a person, comes up for every tool an agent can reach, not only for the agent's final output, which is why the answer has to be a rule applied tool by tool rather than a one-time decision made when the agent was first deployed.

Shrink what needs approval before deciding who approves it

OWASP lists minimizing extensions, minimizing extension functionality, avoiding open-ended extensions such as a general shell execution tool, minimizing extension permissions down to what the downstream system actually needs, such as read-only database access, and executing each extension in the specific user's own context with minimum privileges, as the first lines of defense against Excessive Agency. None of these involve a human clicking approve; they remove the action, the permission, or the blast radius before the question of approval ever comes up.

A tool an agent cannot call does not need an approval gate, and a database connection with read-only rights cannot be the one that deletes a table, regardless of what any approval screen decides. Atipol applies the same ordering inside its own permission model: a sub-agent never has more permissions than the agent that delegated to it, so narrowing what the top-level agent can do narrows every sub-agent underneath it as well.

Translated into an agent's actual configuration, this means an agent used for the ticket workflow this blog has already described gets a file-scope limit and nothing resembling a general-purpose shell tool, an agent that drafts customer replies gets a send function scoped to drafts rather than direct delivery, and an agent that touches a database gets exactly the columns and the read or write rights the task specifies, nothing broader granted for convenience.

Put the gate on high-impact actions, enforced outside the agent

Once unnecessary functionality, permissions, and autonomy are gone, OWASP's sixth mitigation addresses what is left: "Utilise human-in-the-loop control to require a human to approve high-impact actions before they are taken." The guidance adds that this control can sit downstream of the extension call or inside the extension itself, and pairs it with a seventh mitigation, complete mediation: enforcing authorization in the downstream system every time, rather than trusting the model's own judgment about whether an action is allowed.

That second point matters operationally. An approval prompt that the agent itself decides whether to show is not a gate, since a manipulated or simply mistaken agent can skip the prompt the same way it would skip any other instruction. The decision to require approval, and the enforcement of that requirement, has to live in a system the agent does not control.

OWASP also lists two measures that limit damage without preventing Excessive Agency in the first place: logging and monitoring extension activity, and rate-limiting undesirable actions. Both matter, but neither substitutes for the approval gate itself; a well-logged unauthorised deletion is still a deletion, and a rate limit slows repeated damage without stopping the first instance of it.

Where teams actually put the gate

Atipol's use cases show where different teams place that gate, action by action, rather than team by team.

What the gate protects differs by domain, a customer relationship, an active incident, a codebase, a financial statement, but the shape of the gate is the same in every row: one person, other than whoever triggered the action, deciding before it takes effect, not reviewing it afterward.

DomainAction gatedWho decidesScope of the approval
Customer supportSending a reply to a customerThe person who approves the sendThat specific message, once
Security operationsContaining an incidentThe analystThat specific call, once
Software developmentMerging a pull requestA reviewer other than the requesterThat specific call, before merge
ObservabilityOpening a monitoring incidentThe approverThat specific call
Content publishingPublishing to the CMSThe person approving through MCPRouted through MCP approval
Financial reportingSigning off a reportThe CEO or the CFOThat specific report

One call, one decision, never a blanket yes

A gate that stays open after the first approval is not a gate. Atipol enforces the rule as a scope limit: human approval is given for one specific call, once, and each tool carries one of three permission states, allowed, subject to a person's approval, or denied, set tool by tool. When a tool is set to require approval, the call waits for a person's decision; if it is denied, the call is refused and logged rather than retried silently.

The same model only tightens at larger scope, never loosens it: a workspace can move from open, to catalog only, to mandatory approval, but a workspace-level rule cannot be relaxed by an individual agent's configuration. A request outside the approved catalog is decided by an administrator and logged, which keeps the exception visible instead of letting it become a silent default.

These three states apply the same way regardless of which team configured the agent: a support agent's send function, a SOC agent's containment action, and a finance agent's report submission each carry their own allowed, approval, or denied setting, rather than one approval setting applied to the whole agent. Changing a single tool's state does not touch any other tool the same agent can call.

The reviewer is never the requester, and never the agent itself

The same separation that applies to reviewing a ticket applies directly to approval gates: the person who asked for the work should not be the one who approves it. Atipol applies the rule without exception on either side of the request: no agent, human or artificial, approves its own delivery, and the human keeps the final decision on every approval.

In practice this means an agent cannot generate a report and also sign it off, and a developer who assigned a ticket to an agent cannot be the required reviewer who approves the resulting change, the same constraint documented for GitHub's own coding agent pull requests. Role-based tool profiles extend this further: each role gets its own allowed-tool list, with explicit human approval required before any sensitive or irreversible action, rather than one blanket approver for the whole team.

The same rule reaches sub-agents as well. Since a sub-agent never has more permissions than the agent that delegated to it, an approval requirement placed on the top-level agent's sensitive action cannot be bypassed by having a sub-agent perform the same action under a narrower task description; the permission ceiling, and the approval gate that comes with it, travels down the delegation chain.

Approval without a record is not oversight

An approval that is not written down is indistinguishable, six months later, from no approval at all. Atipol's audit log is specific about what it shows: who authorised an action, not only that it happened, and for an irreversible action such as publishing or deleting, the explicit human approval that came before it, recorded alongside the action itself.

Regulators are moving in the same direction for systems they classify as high-risk. The European Commission's own description of the AI Act, last updated 19 October 2026, lists appropriate human oversight measures among the obligations that apply to high-risk AI systems, and states that once such a system reaches the market, deployers must ensure human oversight and monitoring through its use, not only at deployment.

NIST's AI Risk Management Framework (AI RMF 1.0, published 26 January 2023) frames this at a higher level: it is meant to help organizations incorporate trustworthiness considerations into the design, development, use, and evaluation of AI systems, which includes who gets to approve what an agent does, not only what the agent produces.

Building this into a team

None of this requires deciding, action by action, from scratch. Start by removing functionality, permissions, and autonomy the agent does not need, following OWASP's first mitigations; set the tools that remain to one of three states, allowed, approval, or denied; name a reviewer for each gate who is never the requester and never the agent; and log who approved what, with irreversible actions carrying their approval alongside them in the record.

The four steps above translate into a single, repeatable sequence:

Shrink agentscopeGatehigh-impactcallsIndependentreviewerLog whoapprovedShrink agent scopeGate high-impact callsIndependent reviewerLog who approved

A useful test for whether the gate is in the right place: remove the approval step and ask what the worst outcome looks like. If the answer is a few minutes of rework, the action was probably never high-impact enough to need a human in the first place. If the answer is a wrong report signed off, a database table gone, or a message a customer should never have received, the gate belongs exactly where OWASP and Atipol put it: before the action, enforced outside the agent, and recorded afterward.

The security practices behind that model, including per-agent tool allowlists, secrets kept out of prompts, and reviewing an MCP server before connecting it, are laid out at atipol.ai/agentic-ai-blog/mcp-security. The governance framework around roles, the usage policy, and where review has to sit before a merge is covered at atipol.ai/agentic-ai-blog/ai-agent-governance.

To see these permission states, approval gates, and the audit log applied across a team of agents, the security section of the product at atipol.ai/security walks through setting a tool to allowed, approval, or denied, and what gets logged when a person approves or denies a call.

Frequently asked questions

Which AI agent actions need human approval and which don't?

OWASP's guidance on Excessive Agency points to high-impact actions, the ones where a wrong call is costly or hard to reverse, such as publishing, deleting, merging, or sending to a customer. Lower-impact actions are better handled by shrinking the agent's functionality, permissions, and autonomy so fewer of them exist in the first place, rather than by approving each one.

Can the agent or the person who requested the action approve it themselves?

No. Atipol applies the rule that no agent, human or artificial, approves its own delivery, and that the person who asked for the work should not be the one who approves it, the same independent-review rule documented for GitHub's Copilot coding agent pull requests.

What should be logged when a human approves or denies an agent's action?

The log should show who authorised the action, not only that it happened, and for an irreversible action such as publishing or deleting, the explicit approval that came before it, recorded alongside the action in the audit trail.

Sources

Try it on a real project

The public demo shows a fictional organization at work, no account needed. The free plan includes a project, three agents and an agent lead.