Excessive agency

On this page 7

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.

StageWhat happensMissing control
Untrusted inputAgent reads an email containing hidden instructionsInput isolation and content labeling
Model decisionModel plans to forward the inbox to an outside addressPolicy check on planned actions
Tool invocationAgent calls a general mail-sending functionNarrow, purpose-built tool
AuthorizationMail service accepts the request with full user rightsScoped, least-privilege credentials
ExecutionMessages leave the organization without reviewHuman approval for high-impact steps
Stages of an excessive agency incident

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 causeDefinitionTypical example
Excessive functionalityTools expose operations the task never needsA read-only summarizer that can also delete documents
Excessive permissionsCredentials grant broader access than the function requiresA plugin using an administrator token to read one table
Excessive autonomyHigh-impact actions run without independent verificationAn agent that issues refunds with no human confirmation
Root causes and typical examples

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 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.

ConceptPrimary questionRelation to excessive agency
Prompt injectionCan untrusted text steer the modelCommon trigger that exploits excess capability
Agent hijackingCan an attacker take over an agent’s taskOutcome whose damage scales with granted agency
Tool poisoningCan a tool description or result mislead the modelAnother trigger feeding harmful tool calls
AI guardrailsCan outputs be filtered or blockedPartial mitigation that cannot replace least privilege
AI controlCan a misaligned model be contained safelyResearch framing of the same containment problem
How excessive agency relates to neighboring concepts

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 typeRecommended oversightReason
Read public or own dataAutonomous with loggingLow impact and easy to audit
Draft content for reviewAutonomous, output not sentHuman remains the sender
Modify internal recordsScoped permissions plus audit trailErrors are reversible but costly
Send external messagesExplicit user confirmationLeaks and reputational harm are irreversible
Move money or delete dataConfirmation plus downstream policy limitsHighest and permanent impact
Oversight level by action type

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.

MistakeConsequenceFix
Relying on the system promptInjected text overrides the stated rulesEnforce limits in code and access policy
Shared service accountEvery user inherits administrator rightsPer-user delegated credentials
Confirmation fatigueUsers approve prompts without reading themAsk only for genuinely high-impact steps
Vague approval dialogsUsers cannot see what will actually happenDisplay the exact tool call and arguments
Unreviewed third-party pluginsHidden capabilities enter the agentInventory and review every integration
Frequent mistakes and their fixes

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.