Excessive agency: when an agent has too much authority
Excessive agency is the authority an agent holds, not the mistakes its model makes.

An agent turns dangerous not when its model is wrong, but when a wrong answer can do something. The OWASP Top 10 for LLM Applications makes that the definition: Excessive Agency is “the vulnerability that enables damaging actions to be performed in response to unexpected, ambiguous or manipulated outputs from an LLM, regardless of what is causing the LLM to malfunction.”
The last clause carries the whole idea. The trigger may be a benign hallucination, an ambiguous instruction or an injected document, and the entry is deliberately indifferent to which. What converts any of them into damage is the authority the system already held when the bad output arrived.
What excessive agency actually is
A system has agency when the model can act rather than only answer: call functions, reach interfaces, change state in another system. That capability is granted by the developer, and the choice of which extension — tool, skill or plugin — to invoke is increasingly delegated to the model itself, which calls it repeatedly and uses each result to steer the next call. Agency is therefore a decision about authority, and authority can be granted in excess. OWASP names three forms of excess as the root cause, “excessive functionality”, “excessive permissions” and “excessive autonomy”. It is worth separating this from the neighbouring failure of not scrutinising the model’s output at all. OWASP notes that Excessive Agency “differs from Insecure Output Handling which is concerned with insufficient scrutiny of LLM outputs”: one fault is about trusting what the model says, the other about what the model is allowed to do.
The three ways an agent holds too much authority
Excessive functionality — the tool does more than the task needs. A developer wanting an agent to read documents picks an extension that can also modify and delete them, and an open-ended extension such as “run a shell command” exposes every command, not only the one intended. Excessive permissions — the tool is right but the identity it uses downstream is too broad. OWASP’s worked example is explicit: an extension “intended to read data connects to a database server using an identity that not only has SELECT permissions, but also UPDATE, INSERT and DELETE permissions.” Excessive autonomy — the action is correct but nothing stands between the model’s decision and its execution, so a deletion or a message goes out with no independent confirmation.
Why a better model does not remove the risk
It is tempting to treat excessive agency as a model-quality problem and wait for a stronger model. Two facts argue otherwise. First, the trigger is often neither adversarial nor plainly wrong: confabulation is “a natural result of the way generative models are designed”, and NIST AI 600-1 defines it as a system that will “generate and confidently present erroneous or false content in response to prompts”. Second, a human is an unreliable last defence on their own, because automation bias — “excessive deference to automated systems” — makes a confident output more trusted, not less. If the failure enters before the answer is judged, the durable control is the authority that answer can exercise.
Reduce the authority, then keep the check out of the model
The prevention OWASP recommends is a discipline of minimisation in two directions. On the capability side, limit “the extensions that LLM agents are allowed to call to only the minimum necessary”, keep each tool as narrow as its task, prefer a specific operation to an open-ended one, and grant the downstream identity only the permissions the task requires. On the enforcement side, the decision must not live inside the model: “Implement authorization in downstream systems rather than relying on an LLM to decide if an action is allowed or not.” The same principle appears in CISA’s deployment guidance as “least privilege and defense-in-depth”. Microsoft’s AI Red Team states the same control: “safeguards that deterministically control the flow of an agentic AI system’s execution”, limiting “the tools and data that can be used”. Where an action is high-impact, “Utilise human-in-the-loop control to require a human to approve” it before it is taken: the model proposes, something deterministic outside it disposes.
What remains when authority cannot be reduced further
Some useful actions cannot be narrowed to a harmless scope. OWASP is careful to separate the controls that prevent excessive agency from those that only limit the damage — logging and monitoring of extensions and downstream systems, and rate-limiting “to reduce the number of undesirable actions that can take place within a given time period”. These do not remove the authority; they shorten the time before an abuse is noticed.
Level and prerequisites. L4 — this is the security layer of the area: the reader must reason about authority as a design property of an agent (what it may call, what its identity may touch, what it may do unattended), not about a single component. Prerequisites: the L4 sheets on the action loop and on tools, schemas and argument validation, and the L3 sheets on how a model generates text and where untrusted input enters.
Where to go next
- Automation & AI — the macro-area this sheet belongs to.
- Operations and risk — the node this sheet sits in.
References
- OWASP — Top 10 for LLM Applications — the definition of Excessive Agency, its three root causes, the worked permission example and the prevention list.
- NIST — AI 600-1 — the definition of confabulation and the account of automation bias.
- CISA — Deploying AI Systems Securely — least privilege and defense-in-depth as a deployment control.
- Microsoft AI Red Team — Taxonomy of Failure Mode in Agentic AI Systems — deterministic control of an agent’s execution flow and limiting the tools and data it may use, as the systems-side form of the enforcement point.