Excessive agency, as OWASP’s Top 10 for LLM Applications defines it, is a vulnerability that exists when an application grants an LLM-based agent more autonomy, functionality, or system permission than the task it performs actually requires. It’s worth being precise about what this risk actually is: it’s not that the agent will maliciously decide to misuse its access on its own. It’s that the surplus access — beyond what the task needs — becomes exactly what a successful manipulation (through prompt injection or any other means) can exploit, and the size of that surplus determines how bad a successful manipulation can be.
The three sources OWASP identifies
Excessive functionality — the agent has access to tools or capabilities beyond what its specific task requires. An agent built to answer questions about a product catalog that also has access to a tool for modifying inventory records has excessive functionality if inventory modification was never actually part of its intended use case; it’s capability granted “just in case” or inherited from a broader toolset without deliberate scoping to the actual task.
Excessive permissions — the agent’s access to a given tool or system is broader than the task requires, even when the tool itself is appropriate. An agent that needs to read customer records but has been granted read-and-write access to the entire customer database, because it was simpler to configure one broad permission than several narrow ones, exhibits excessive permission on an otherwise appropriately chosen tool.
Excessive autonomy — the agent can take consequential actions without requiring human review or confirmation, when the stakes of the action would reasonably justify a human checkpoint. An agent authorized to autonomously approve refunds up to an unlimited amount, rather than requiring confirmation above a threshold, has excessive autonomy regardless of whether its functionality and permissions are otherwise appropriately scoped.
These three are independent dimensions — an agent can be over-provisioned on any one of them while the others are reasonably scoped, and a full risk assessment needs to check all three separately rather than treating “agent access” as a single thing to evaluate.
Why this accumulates in practice
Reusing an existing broad role or credential for a new agent because it’s already configured and working, rather than provisioning a purpose-scoped identity for the new use case — the same pattern that causes IAM permission sprawl generally, but with a distinct twist for agents: the “user” being over-provisioned isn’t a person who might exercise judgment about whether to actually use excess access, it’s a system whose behavior in edge cases isn’t fully predictable.
Granting broad access preemptively to avoid future friction — anticipating that an agent might eventually need broader functionality and provisioning for that anticipated future need upfront, rather than expanding access incrementally as actual requirements become concrete. This trades a small amount of future reconfiguration effort for a live, ongoing excess-access risk in the meantime.
Treating agent autonomy as a product feature to maximize without a corresponding, explicit conversation about what the actual cost of an error or manipulated action would be — autonomy reduces friction and is often treated as an unambiguous improvement, without the tradeoff being made visible in the same way a security review would surface it for a more traditional system change.
How to actually scope each dimension down
For functionality: provision tools per-agent, per-task, rather than granting a shared toolset “in case it’s needed.” If an agent’s job is answering questions, it doesn’t need write-capable tools at all, even ones adjacent to its domain.
For permissions: apply the same least-privilege discipline to an agent’s credentials that you’d apply to any service account — read-only where read-only suffices, scoped to specific resources or record types rather than broad database or system-wide access, using the narrowest role your access model can express.
For autonomy: set explicit thresholds for what requires human confirmation versus what can proceed autonomously, based on the actual cost of an incorrect or manipulated action — a low-stakes action (drafting a suggested response) can reasonably proceed autonomously; a high-stakes one (sending an external communication, modifying financial data, deleting records) should require a checkpoint regardless of how well-tested the agent’s normal behavior appears to be.
Auditing existing agent deployments for excessive agency
For any agent already in production, an explicit review asking, for each granted tool and permission: “does the agent’s actual task require this, specifically, or was it granted for convenience or anticipated future need” surfaces excess that accumulated the same way IAM permission sprawl accumulates elsewhere — gradually, through reasonable-seeming individual decisions that nobody circled back to tighten. This review is worth treating as a recurring practice as agent capabilities and deployments expand, not a one-time cleanup.
The relationship to prompt injection
Excessive agency and prompt injection are frequently discussed together because they compound each other directly: prompt injection is often the mechanism that manipulates an agent’s behavior, and excessive agency is what determines how much damage that manipulation can actually cause once it succeeds. An agent with minimal functionality, tightly scoped permissions, and appropriate autonomy limits has a small blast radius even against a successful injection attempt — which is precisely why permission and functionality scoping is treated as the primary, most reliable defense against the broader category of AI agent manipulation risk, rather than injection-prevention techniques alone.
