OWASP LLM06 Excessive Agency: how an approval gate limits it

OWASP's LLM06:2025 names three causes: too many tools, too much permission, too much autonomy. What an approval gate fixes, and what it leaves to you.

· 7 min read

OWASP’s Top 10 for LLM Applications lists Excessive Agency as LLM06:2025. It describes the vulnerability as the one that “enables damaging actions to be performed in response to unexpected, ambiguous or manipulated outputs from an LLM”. The cause of the bad output does not matter: a hallucination, a prompt injection in an email the agent read, or a compromised tool. What matters is that the output was allowed to do something.

Three root causes

OWASP names three, and most incidents involve more than one. In agent terms:

Excessive functionality
The agent has tools it does not need: a mailbox tool that can send when the job is to summarise, or a shell when it needs one script.
Excessive permissions
The tools reach further than the job: a database login that can drop tables, an API token with admin scope.
Excessive autonomy
High-impact actions run without anyone independently checking and approving them.

What an approval gate fixes

An approval gate is a direct answer to the third cause. One of OWASP’s listed mitigations is to require user approval: “Utilise human-in-the-loop control to require a human to approve high-impact actions before they are taken.”

It also helps with a second mitigation, complete mediation: authorisation enforced outside the model rather than left to the model to decide. That only holds if the check sits in the code that performs the action. A tool the model can call without asking, or an instruction in the prompt to “always ask first”, is still the model deciding.

  • Fail closed. Pending, denied, expired, withdrawn and an unreachable service all mean the action does not happen. Only allowed: true means go.
  • Ask with what will actually run. Build the summary and details from the arguments your code is about to execute. A manipulated model can describe a harmful action innocently; your code cannot.
  • Rules by key, not by name. A model can call itself anything. A rule for one agent goes by the key that agent asks with, and an agent key cannot read the inbox, decide, or write rules.
  • Limit the damage of what is allowed. An allow rule can carry an amount limit and a budget per day, week or month, so a manipulated agent cannot repeat an allowed action without end.
// The summary is built from what the code will do, not from what the model said.
await approvals.guard(
  {
    action: recipients.length > 1 ? "email.send_bulk" : "email.send",
    summary: `Email ${recipients.length} people: ${subject}`,
    details: { to: recipients.slice(0, 5).join(", "), subject, body: body.slice(0, 1000) },
  },
  () => mailer.send({ to: recipients, subject, body })
);

What it does not fix

A gate is one control. It leaves the other two causes, and some of OWASP’s other mitigations, to you:

  • Minimise extensions and their functions. Remove the tools the agent does not need. A gate on a tool that should not exist is a question nobody should have to answer.
  • Avoid open-ended extensions. OWASP names running a shell command and fetching a URL as examples. The Claude Code and Codex hooks can put every shell command through approval, but a rule sees the action shell.run, not the command, so every one of them asks. A narrow tool is easier to approve than a shell.
  • Minimise permissions. Give the agent credentials that cannot do what you would never approve. A deny rule and a missing permission fail in different ways, which is the point of having both.
  • Execute in the user’s context. Actions on behalf of a user should run with that user’s rights, not a service account’s.

A person approving a request can only judge what the request shows. If the summary is vague, the approval is too. Name the amount, the recipient, the count.

A check for each tool

For every tool your agent can call, write down three answers:

Does it need to exist?
If the agent's job does not need it, remove it. That ends both the functionality and the permission problem for that tool.
What can its credentials do?
Scope them to the job. Read-only where reading is the job.
Who decides when it acts?
Nobody, a standing rule with a limit, one person, two people, or never. That answer becomes a rule.

Sorting actions into those answers is covered in risk tiers for agent actions. The other controls an agent needs in production, from permissions to an audit trail, are in AI agent guardrails. The guarantees VariantGate itself keeps are on Security.

Sources

  1. OWASP Gen AI Security Project: LLM06:2025 Excessive Agency
  2. OWASP Top 10 for LLM Applications, 2025 list