Waxell

AI Agent Approval Workflows: Oversight That Scales [2026]

Only 19.7% of orgs secure and govern every AI agent before go-live. Three approval architectures that add oversight without burning out reviewers.

Logan KellyUpdated 18 min read

On 29 July 2026, Google published CVE-2026-18236 against its Agent Development Kit. The NVD entry calls it "continuation forgery in tool confirmations": an attacker who could inject events into an agent's session history was able to execute unauthorised tools by forging the confirmation response that was supposed to represent a human saying yes. Three checks were missing at once — the framework never verified that the tool belonged to the executing agent, never validated that the tool actually required confirmation, and never matched the confirmation arguments against the original tool call. Versions below ADK 2.5.0 are affected. Six days later, AWS disclosed CVE-2026-18830 in the Bedrock AgentCore harness — crafted content blocks in conversation messages could execute configured tools while bypassing model invocation and the surrounding security controls. AWS rates it 8.6 High and says it has fixed it with no customer action required.

Two different vendors, six days apart, the same class of defect: the approval step existed, and it could be walked around.

That is the harder half of human-in-the-loop, and the survey data below suggests it is the half most teams skip. The easy half is deciding that a human should approve something. The hard half is building a gate that is load-bearing — that fires on the right actions, that a reviewer can actually evaluate, and whose "approved" is a fact rather than a string in a message history.

Human-in-the-loop (HITL) for AI agents is the practice of inserting human review, approval, or intervention into agent workflows at defined trigger points — before, during, or after specific actions. Effective HITL design specifies not just that humans can intervene, but when escalation fires, what reviewers see, how fast they need to respond, what happens when they don't, and how the approval itself is authenticated. This is distinct from human-on-the-loop (HOTL), where agents execute by default and a human monitors with the ability to intervene — a weaker control that preserves velocity but requires robust monitoring infrastructure.

Most teams get the first sentence right and skip everything after it.

The Problem With "Just Add Approval"

The instinct is to put approval gates in front of anything that feels risky. That instinct is correct. The failure mode is in execution: approval gates designed around action categories ("anything that writes to a database needs review") rather than actual risk signals produce three predictable outcomes.

The first is latency. A synchronous approval gate that requires a human response before the agent continues adds real delay — anywhere from 30 seconds to several hours, depending on reviewer availability. For agents operating in time-sensitive workflows, that's not a governance cost you can absorb. You end up removing the gate to restore velocity, which leaves you with no oversight at all.

The second is fatigue. High-volume review queues degrade quickly, and security operations learned this the hard way a decade before agents existed. A 2025 ACM Computing Surveys review of alert fatigue in security operations centres records the industry baseline it was built on: a Trend Micro survey in which 54% of SOC teams report feeling overwhelmed by alert volume, 55% lack confidence in prioritising or responding to alerts, and analysts spend 27% of their time handling false positives — while IBM's survey found teams resolving only 49% of the alerts assigned to them in a workday. The authors define alert fatigue as the point at which "excessive alerts overwhelm analysts, leading to desensitisation, ignored alerts, and potentially missed threats or security breaches." Agent approval queues inherit the whole pathology: imprecise trigger logic floods reviewers with low-risk escalations that could have been auto-approved, and buries the genuinely high-risk decisions in the noise. The pattern is familiar enough to describe from the inside — a team gates every action above a risk score, hits two hundred review requests a day by month two, starts batching approvals to stay above water, and six months later has a near-perfect approval rate and almost no real oversight. Every box checked. Nobody watching.

The third is the one the ADK and AgentCore CVEs expose: the gate can be bypassed. An approval decision that travels through the same channel the agent controls — a message history, a conversation buffer, a tool-result blob — is not an authorisation. It is a suggestion the agent is trusted to honour.

The scale of the gap is measurable. Gravitee's State of AI Agent Security, a survey of 750 senior technology leaders across the UK and US published in April 2026, found that mean monitoring coverage sits at 52% — meaning 48% of AI agents in production are running unsecured — and that only 19.7% of organisations say all their agents are fully secured and governed before going live. No single pre-deployment control in that survey is used by even 40% of organisations: a named person accountable for agent behaviour (37.8%), a security review from IT or the CISO (35%), a documented process to pause or revoke access (34.1%).

The consequences are no longer hypothetical. A Cloud Security Alliance survey of 418 IT and security professionals, commissioned and financed by Token Security and published in April 2026, found that 65% of organisations experienced at least one AI-agent-related incident in the preceding year, with data exposure (61%), operational disruption (43%) and financial cost (35%) the reported impacts. The same survey asked what happens when an agent exceeds its scope: 38% said the action requires human approval, 24% require it to be logged, and only 11% will automatically block it. For most organisations, the answer to an out-of-scope agent action is a person — which makes the design of that person's queue a security control, not a workflow detail.

Scale changes the shape of the problem rather than the problem itself. When Wiz Research examined Moltbook, a social platform built for AI agents, on 31 January 2026, it found a misconfigured Supabase database with full read and write access to production data: 1.5 million agent API tokens, 35,000 email addresses, and 4,060 private agent-to-agent conversations, some containing plaintext third-party API keys. The platform was secured within hours. The finding that matters here is the one Wiz drew out separately: 1.5 million registered agents sat behind roughly 17,000 human accounts, an 88:1 ratio, because there were no rate limits and no way to verify whether an "agent" was an agent at all. Wiz frames this as a metrics-and-guardrails problem in an early category rather than as the cause of the breach — and it is precisely the problem an approval workflow inherits. You cannot route a decision to an accountable human if the system cannot tell you which human is behind the thing asking.

All of these failure modes share a root cause: the approval workflow was designed after the agent, as a filter on its output, rather than designed first as an architectural layer the agent operates within — with its own identity, its own record, and its own trust boundary.

What Should Actually Trigger Human Review

Before you write any agent logic, define your escalation triggers. The CSA survey suggests the industry is converging on two signals already — action risk (63%) and human authorisation (53%) are the most-cited bases for governing agent behaviour — but the useful version has four categories:

Action value. What's the potential cost of this action going wrong — in money, data, or reversibility? Sending an email is low-cost and reversible. Executing a financial transaction is not. Deleting records is not. Map your agent's action space by reversibility first, then by magnitude. The irreversible, high-magnitude quadrant always escalates. The reversible, low-magnitude quadrant rarely needs to.

Confidence threshold. If your underlying model exposes confidence or uncertainty signals, use them. A well-calibrated model that says "I'm 94% confident this is the right action" is materially different from one that says "I'm 61% confident." Hard action-category rules don't capture this. Confidence-based gating is harder to implement but reduces noise dramatically — which means reviewers see fewer, higher-signal requests.

Anomaly detection. Is this action normal for this agent, this user, this context? An agent that usually sends 5–10 outreach emails per run suddenly trying to send 400 should escalate regardless of how confident it is. Statistical outliers from established behaviour patterns are a strong signal that something has changed, even if nothing in the action itself looks wrong. Scope drift is its own category of failure here, and it is covered in depth in AI Agent Permissions: Humans Miss 1 in 3 Threats →.

Regulatory or data classification. Some actions escalate by rule, full stop — not because of risk scoring, but because the compliance framework requires documented human authorisation. PII access, financial execution, healthcare record modification. Know which categories in your domain are regulatory triggers and treat them as hard escalation rules, not soft ones.

Where the EU AI Act actually lands

The regulatory picture changed in 2026, and a lot of published guidance has not caught up. Article 14 of the EU AI Act is the human-oversight requirement, and it binds providers: high-risk systems must be designed and developed so that they "can be effectively overseen by natural persons during the period in which they are in use," including the ability to intervene or interrupt the system through a stop button or similar. The matching obligation on the deployer sits in Article 26(2) — "deployers shall assign human oversight to natural persons who have the necessary competence, training and authority, as well as the necessary support" — alongside Article 26(6), which requires deployers to retain automatically generated logs for at least six months.

The dates moved. The AI Omnibus entered into force on 27 July 2026, and the European Commission now states that rules for high-risk AI systems in Annex III apply from 2 December 2027, and for high-risk AI embedded in physical products under Annex I from 2 August 2028. Article 14 and Article 26 carry those same dates. If you are working from a plan that says August 2026, the plan is out of date — and the extra time is worth spending on the mechanism rather than the memo, because designing oversight that functions under production load takes longer than documenting that it exists.

Three Architectures, Three Trade-offs

Once you know what triggers escalation, you need an architecture that handles it. There's no universal right answer — each pattern makes different trade-offs. For a detailed look at how these patterns work in a real cloud environment, see AWS Security Agent Is Generally Available. Is Your Governance? →

Synchronous gate-keeping. The agent pauses before a critical action and waits for a human decision. Maximum control, highest latency. This is the right choice when the action is irreversible and the cost of a wrong decision outweighs the cost of waiting. The implementation (LangGraph's interrupt pattern, for example) is well-documented. The operational requirement is that reviewers are responsive — if they're not, the agent stalls.

Asynchronous escalation. The agent logs the decision point, queues the request, and continues working on other tasks while waiting for a response. Lower latency, more complex implementation. The hard problem is rejection handling: if a human says no after the agent has already taken other actions that assumed approval, what's the recovery path? This needs explicit design — you can't retrofit it. Map the rejection scenarios before you build the queue, and be honest about whether you can actually stop the thing once it's moving; AI Agent Kill Switch: Only 5% Confident of Containment → covers why that's harder than it sounds.

Parallel feedback architecture. The agent executes while a human reviews in parallel. The system only halts if the review returns a rejection within a defined window. This is the sweet spot for many production workloads — minimal latency impact in the majority of cases, with a meaningful backstop when the reviewer catches something. The catch: it requires robust rollback capability, since the agent may have already acted by the time a rejection arrives. If your agent's actions aren't rollback-safe, don't use this pattern.

Most production systems end up with a hybrid, and the survey data says that is already the norm rather than the aspiration: in the CSA sample, 53% of organisations run agents autonomously for low-risk tasks with human review for higher-risk actions, 24% use human-in-the-loop for most tasks, and only 13% report fully autonomous models. Synchronous gates for irreversible high-stakes actions, async escalation for medium-risk decisions, parallel feedback for routine operations with anomaly triggers.

Whichever you pick, the confirmation has to be authenticated outside the agent's own context. The ADK defect was not that the gate was in the wrong place — it was that the framework accepted a confirmation without checking that the tool required one, that it belonged to the calling agent, or that its arguments matched the call it claimed to answer. Approval is an authorisation decision. Treat it like one: bind it to the specific call, to an identity, and to a record the agent cannot write.

Designing Against Approval Fatigue

A system that produces 200 approval requests per day isn't a human oversight system. It's a liability generator. Writing in a SiliconANGLE guest column in January 2026, Holistic AI co-CEO Emre Kazim argues that traditional human review models are collapsing as agentic systems move into production, and that "humans cannot meaningfully track or supervise AI at machine speed and scale." His conclusion is that automated oversight has to operate at parity with the systems it watches, with humans moving up a level to set the thresholds and own the outcomes. You don't have to accept the whole argument to accept the constraint behind it: reviewers who can't give meaningful attention to each request will approve by default, which means your gate is providing false assurance — the worst outcome.

Build reviewability into your escalation design from the start:

Show reviewers what they need to decide, not everything the agent knows. A request that arrives with 40 lines of context is harder to evaluate than one that surfaces the specific action, the confidence score, and the two or three signals that triggered escalation. The reviewer's cognitive load is your constraint. Design the escalation payload the way you'd design a good pull request description.

Route by expertise, not just availability. Not all reviewers are qualified to evaluate all escalation types. A financial compliance officer and a backend engineer are both humans, but they're not interchangeable for approving a wire transfer. Tiered routing by action category and reviewer expertise reduces mistakes and reduces noise per reviewer — and it is the operational form of what Article 26(2) asks for when it requires oversight to be assigned to people with the necessary competence and authority.

Build an approval record from day one. Every escalation, every decision, and the identity attached to it should be recorded — not for compliance theatre, but because this data tells you whether your triggers are calibrated correctly. If your approval rate is above 90%, your triggers are too broad. If it's below 70%, they might be too narrow. Waxell's execution records are built for this shape of question: every run produces a durable, exportable record of which agent ran, which tools were called, which policies were evaluated and what the outcome was, captured at execution time rather than reconstructed from logs afterwards.

Set escalation SLAs and design for timeout. What happens if no one responds in 4 hours? In 24 hours? "The agent waits forever" is not an answer. Define the timeout behaviour explicitly: auto-approve, auto-reject, or escalate to a backup reviewer. Unanswered escalations that silently stall workflows are how teams get into the habit of approving without reading.

Assume the reviewer will be wrong sometimes, and instrument for it. Human review is a control with a measurable error rate, not a guarantee. Meta's rogue-agent incidents are the reference case for what that looks like at a company with resources most teams don't have — covered in depth here. Evaluation environments are not a safe harbour either: agents have broken out of them, as the Gemini evaluation-breakout findings → showed.

How Waxell handles this: human approval gates are one of the 50+ policy categories Waxell ships, defined once in the governance plane and applied by reference to every workflow that references them — so the rule lives outside the agent's code and changes without a deploy. Alongside the approval gate, the documented categories include Quality, which blocks outputs that fall below configured quality thresholds, Budget, which warns, throttles or blocks as spend reaches a limit, and Kill Switch, a circuit breaker triggered by error rates or anomalies — the same trigger classes described above, expressed as policy objects rather than agent instructions. In Waxell Runtime, a policy trigger that requires human input pauses execution and waits, then resumes from the exact point it stopped rather than from the beginning, because workflows checkpoint at every step; Runtime is what you build inside, using the Waxell SDK decorators, and managed Runtime is included on the Business plan. For agents Waxell cannot run code inside — Claude Code, Cursor, Cowork, vendor and custom MCP agents — Waxell Connect provides the human-in-the-loop inbox and escalation routing, plus the versioned record of every hand-off, with no SDK and no changes to those agents. Book a 30-minute demo →

Approval workflows designed as afterthoughts degrade into rubber-stamping or get removed entirely. Designed upfront, as a first-class architectural layer — with authenticated approvals, calibrated triggers, and a record the agent cannot edit — they're the difference between autonomous agents and supervised autonomy, where agents move fast when it's safe and slow down when they must. That second version is the one that can actually ship at scale.

Sources

FAQ

Four trigger categories are worth reasoning about explicitly: action reversibility and magnitude (irreversible or high-cost actions escalate), model confidence (low-confidence decisions escalate), behavioural anomalies (statistical outliers from normal agent behaviour), and regulatory classification (categories that require documented authorisation by rule). The most reliable systems use a combination — hard rules for regulatory triggers, dynamic scoring for the rest. In the Cloud Security Alliance's April 2026 survey, action risk (63%) and human authorisation (53%) were the two most-cited signals organisations use to govern agent behaviour.

Human-in-the-loop (HITL) means a human must approve before the agent proceeds — the agent is paused awaiting a decision. Human-on-the-loop (HOTL) means a human monitors and can intervene, but the agent continues executing by default. HITL provides stronger control at higher latency cost; HOTL preserves velocity but requires robust monitoring and fast intervention capability. Most production systems need both, applied to different action categories.

In at least one shipped framework, yes. CVE-2026-18236, published by Google to the NVD on 29 July 2026, describes "continuation forgery in tool confirmations" in the Agent Development Kit: an attacker able to inject events into the session history could execute unauthorised tools by forging a tool-confirmation response, because the framework did not check that the tool was registered to the executing agent, that it actually required confirmation, or that the confirmation arguments matched the original call. Versions below ADK 2.5.0 are affected. A related disclosure, CVE-2026-18830 in the Amazon Bedrock AgentCore harness (NVD, 4 August 2026; 8.6 High per AWS), describes crafted content blocks executing configured tools while bypassing model invocation and security controls. The design lesson is the same in both: an approval that travels through a channel the agent can write to is not an authorisation. Bind it to the specific call and to a verified identity.

Article 14 requires providers of high-risk AI systems to design them so they can be effectively overseen by natural persons in use, including the ability to disregard, override or interrupt the system. Article 26(2) requires deployers to assign that oversight to people with the necessary competence, training and authority, and Article 26(6) requires deployers to keep automatically generated logs for at least six months. Neither article mandates a specific approval architecture. The timing changed in 2026: following the AI Omnibus, which entered into force on 27 July 2026, the European Commission states that rules for high-risk systems in Annex III apply from 2 December 2027 and for high-risk AI embedded in physical products under Annex I from 2 August 2028. Earlier guidance citing 2 August 2026 for these obligations is superseded.

Three architectural patterns handle the core trade-offs: synchronous gate-keeping (agent pauses and waits — maximum control, highest latency), asynchronous escalation (agent continues on other tasks while approval is pending — lower latency, requires rejection handling), and parallel feedback (agent executes while a human reviews in parallel, halting only on rejection — lowest latency, requires rollback capability). Most production systems use a hybrid. Whichever pattern you choose, authenticate the approval outside the agent's own context, bind it to the specific call, and record the decision somewhere the agent cannot rewrite.

Escalation paths define the sequence of handoffs when an agent reaches a decision point requiring human input: who receives the escalation, what information they see, how long they have to respond, what happens if they don't, and how the resulting approval is authenticated. Well-designed escalation paths include reviewer routing by expertise, timeout behaviour, and rejection handling — not just a notification sent to a generic inbox.

Three design decisions reduce fatigue: precise trigger logic (escalate based on risk signals, not action categories, to reduce queue volume), reviewer routing by expertise (fewer irrelevant escalations per reviewer), and SLA-enforced timeouts (prevents unresolved queues from becoming rubber-stamp queues). Monitoring your approval rate over time is the simplest leading indicator — rates above 90% suggest triggers are too broad. The security operations literature is the closest analogue: a 2025 ACM Computing Surveys review of SOC alert fatigue records survey findings of 54% of teams feeling overwhelmed by alert volume and analysts spending 27% of their time on false positives.

Past a certain ratio, review stops being a control and becomes a formality — and the first thing to break is usually attribution rather than capacity. Wiz Research's examination of the Moltbook platform in January 2026 is the clearest published illustration: 1.5 million registered agents behind roughly 17,000 human accounts, with no rate limiting and no mechanism to verify whether an "agent" was autonomous or a human with a script. Wiz treats that 88:1 ratio as a guardrails-and-metrics problem in a young category, not as the cause of the breach it found, but the implication for approval design holds: you cannot route a decision to an accountable person if the system cannot establish who is behind the request. The answer isn't more reviewers — it's policy-level enforcement that applies automatically, with human review reserved for decisions that genuinely require judgement.