Excessive agency is a vulnerability in which a system built on a large language model is granted more functionality, permissions or autonomy than its task requires, so that a manipulated or mistaken model output can trigger damaging actions in connected systems. In AI safety and application security for artificial intelligence, it describes the gap between what an AI agent is able to do and what it should be allowed to do.
The concept is listed as a distinct risk in the OWASP Top 10 for LLM Applications, where it appears as LLM06 in the 2025 edition. It matters because language models are non-deterministic and steerable by untrusted text: once a model can call tools, send messages or modify data, every weakness in its reasoning becomes a potential real-world side effect.
How excessive agency turns model errors into actions
Excessive agency arises when an LLM output is passed directly to a tool that changes state, such as a database, an email account, a file system or a payment interface. The model itself does not need to be malicious; it only needs to produce a plausible but wrong instruction, and the surrounding application executes it with whatever privileges the integration holds.
The triggering input usually comes from one of three places: hallucinated or misinterpreted reasoning, a direct or indirect prompt injection hidden in documents, web pages or emails the agent reads, or a compromised tool or plugin that returns poisoned results. Excessive agency is therefore best understood as the impact amplifier that sits downstream of these attacks, rather than as an attack technique on its own.
The chain below shows how a single untrusted input becomes a harmful action when no control interrupts it.
| Stage | What happens | Missing control |
|---|---|---|
| Untrusted input | Agent reads an email containing hidden instructions | Input isolation and content labeling |
| Model decision | Model plans to forward the inbox to an outside address | Policy check on planned actions |
| Tool invocation | Agent calls a general mail-sending function | Narrow, purpose-built tool |
| Authorization | Mail service accepts the request with full user rights | Scoped, least-privilege credentials |
| Execution | Messages leave the organization without review | Human approval for high-impact steps |
The three root causes of excessive agency
Security practice distinguishes three root causes, and real incidents often combine more than one. Separating them helps teams decide which control removes the risk most cheaply.
| Root cause | Definition | Typical example |
|---|---|---|
| Excessive functionality | Tools expose operations the task never needs | A read-only summarizer that can also delete documents |
| Excessive permissions | Credentials grant broader access than the function requires | A plugin using an administrator token to read one table |
| Excessive autonomy | High-impact actions run without independent verification | An agent that issues refunds with no human confirmation |
Excessive functionality often comes from convenience: developers wrap a generic capability, such as running shell commands or calling arbitrary URLs, instead of building a narrow function with fixed parameters. Excessive permissions usually come from reusing a service account or a privileged user identity for downstream calls. Excessive autonomy reflects a product decision to remove friction, which also removes the last point where a person could catch an error.
Open-ended tools are particularly risky because the model chooses their arguments. A function named run_command or http_request effectively hands the model an unbounded action space, while a function such as get_order_status(order_id) constrains both the operation and the data it can touch.
Excessive agency compared with related AI security risks
Excessive agency overlaps with several neighboring concepts in AI safety, but each describes a different link in the failure chain. Treating them separately prevents teams from fixing the trigger while leaving the impact unchanged.
| Concept | Primary question | Relation to excessive agency |
|---|---|---|
| Prompt injection | Can untrusted text steer the model | Common trigger that exploits excess capability |
| Agent hijacking | Can an attacker take over an agent’s task | Outcome whose damage scales with granted agency |
| Tool poisoning | Can a tool description or result mislead the model | Another trigger feeding harmful tool calls |
| AI guardrails | Can outputs be filtered or blocked | Partial mitigation that cannot replace least privilege |
| AI control | Can a misaligned model be contained safely | Research framing of the same containment problem |
The key distinction is that prompt injection has no complete fix with current models, whereas excessive agency is largely a design choice that engineers control. An application that cannot perform a dangerous action is safe from that action regardless of how the model is manipulated, which is why practitioners prioritize reducing agency over trying to perfect input filtering.
Controls that limit agent capability
Effective mitigation applies the principle of least privilege to every layer of an agent: the set of tools, the scope of each tool, the identity used for downstream calls and the decisions the agent may take alone. The most reliable controls are enforced outside the model, in code and access policies, because instructions in a system prompt can be overridden by injected text.
- Minimize tools: register only the functions the use case needs and remove experimental plugins before release.
- Narrow each function: replace generic shell, SQL or HTTP access with operations that accept validated, typed parameters.
- Act in the user’s context: use delegated, scoped tokens such as OAuth scopes so the agent never exceeds the requesting user’s rights.
- Require human approval for irreversible or high-value actions, showing the exact action and its parameters.
- Enforce authorization downstream: the target system checks every request instead of trusting the LLM’s decision.
- Log and rate-limit tool calls so that anomalous bursts are visible and their damage is bounded.
Choosing the right level of oversight depends on how reversible and how costly an action is. The decision table below reflects common practice in agent design reviews.
| Action type | Recommended oversight | Reason |
|---|---|---|
| Read public or own data | Autonomous with logging | Low impact and easy to audit |
| Draft content for review | Autonomous, output not sent | Human remains the sender |
| Modify internal records | Scoped permissions plus audit trail | Errors are reversible but costly |
| Send external messages | Explicit user confirmation | Leaks and reputational harm are irreversible |
| Move money or delete data | Confirmation plus downstream policy limits | Highest and permanent impact |
Common mistakes when granting agency
Most excessive agency findings in security assessments stem from a small set of recurring design shortcuts. Recognizing them early is far cheaper than retrofitting controls after deployment.
| Mistake | Consequence | Fix |
|---|---|---|
| Relying on the system prompt | Injected text overrides the stated rules | Enforce limits in code and access policy |
| Shared service account | Every user inherits administrator rights | Per-user delegated credentials |
| Confirmation fatigue | Users approve prompts without reading them | Ask only for genuinely high-impact steps |
| Vague approval dialogs | Users cannot see what will actually happen | Display the exact tool call and arguments |
| Unreviewed third-party plugins | Hidden capabilities enter the agent | Inventory and review every integration |
A further misconception is that a more capable or better aligned model removes the need for these controls. Improved models make errors less frequent, but non-zero error rates multiplied by broad permissions still produce incidents at scale, so the alignment tax of least privilege remains worth paying.
The idea in brief
Excessive agency means giving an AI assistant more power than its job needs. Imagine hiring someone to water your plants and handing them the keys to your car, your safe and your bank account. They may be perfectly honest, but if someone tricks them, or they simply misunderstand a note, the damage can be serious.
AI assistants can be tricked by text they read and can make confident mistakes. The safe approach is simple: give the assistant only the tools it needs, only the access it needs, and ask a person to approve anything that cannot be undone.
A practical scenario
A mid-sized retailer deploys a customer support agent that reads incoming emails and answers order questions. The first prototype connects the agent to the full order management API with an administrator key, including functions for refunds, address changes and account deletion. During a security review, a tester sends an email containing hidden instructions to refund an order to a different card, and the agent attempts the refund.
The team redesigns the integration around least privilege. The agent now has three narrow tools: look up order status, draft a reply and open a refund request. Each call uses a token scoped to the customer who wrote the email, and every refund request goes to a human agent who sees the amount and destination before approving it.
In the repeated test, the injected instructions still confuse the model, but the agent can no longer move money or touch other accounts. The outcome is a support assistant that still answers most inquiries automatically while the worst case is reduced to a misleading draft reply that a person can correct.