Blog

Excessive Agency: Scoping What Your AI Agents Can Do

Every serious agent incident has the same shape. The injection is the interesting part of the story. The damage is always the boring part—the agent could do something it never needed to be able to do.

Excessive Agency: Scoping What Your AI Agents Can Do

Key Takeaways

  • Excessive agency (OWASP LLM03:2026) is an AI agent holding more capability, permission, or autonomy than its task requires. It is the control that converts a language problem into a systems breach.
  • It shows up in three forms: excessive functionality (tools it does not need), excessive permissions (scope beyond the job), and excessive autonomy (no approval gate on irreversible actions).
  • The reason it is so common is convenience: teams grant the broad integration scope because narrowing it per task is work, and nothing fails when they do.
  • The fix is a capability budget per agent—enumerate tools, scope parameters, gate the irreversible, and authorize at call time.
  • Measure granted scope against exercised scope. Permissions never used in ninety days are the cheapest risk reduction available to you.

Every serious agent incident we have reviewed has the same shape. The injection or the misunderstanding is the interesting part of the story. The damage is always the boring part: the agent could do something it never needed to be able to do.

OWASP calls this excessive agency, and it holds the LLM03 slot in the 2026 Top 10 for LLM Applications, up from LLM06 in the 2025 edition. It is the least glamorous entry on the list and the one that most reliably determines whether an incident is an anecdote or a disclosure.

What Excessive Agency Actually Means

An agent has excessive agency when its capability envelope is larger than its job. That envelope has three dimensions, and teams usually over-provision all three at once.

Excessive functionality. The agent has tools it does not need. A document-summarizing agent connected to a database client that supports writes, because that was the available client. An internal helpdesk agent that can send external email, because the mail tool did not distinguish.

Excessive permissions. The tools are right; the scope is not. Read access to an entire share when the workflow touches one folder. A cloud role with a wildcard because the specific ARN list was tedious to assemble.

Excessive autonomy. The agent takes irreversible action without a human in the loop. Refunds issued, records deleted, tickets closed, messages sent—no approval, no reversal path, and often no notification.

Why Well-Run Teams Over-Provision Anyway

This is not carelessness, and treating it as carelessness produces a security program nobody cooperates with. There are structural reasons.

Scoping is invisible work with no immediate payoff. A broad credential works on the first try. A narrow one produces a week of permission errors and a frustrated product team. Under deadline, breadth wins every time.

The agent’s needs are genuinely unclear at design time. Traditional integrations have enumerable call paths. An agent’s requirements emerge from usage, so teams provision for the superset they can imagine.

Tool granularity is inherited, not chosen. If the available MCP server exposes a broad tool, that is the granularity you get, regardless of what you wanted.

Nothing fails when you get it wrong. Over-provisioning has no symptom. It sits there, working perfectly, until the day it does not.

The Capability Budget

The framing that works with engineering teams is a budget rather than a prohibition. Every agent gets an explicit allowance, written down, enforced at runtime, and reviewed.

Step 1: Enumerate the envelope

For each agent in production, list every tool, every credential, every system reachable, every data classification in scope, and every action that cannot be undone. Most teams have never written this down, and the act of writing it produces the first round of cuts on its own.

Step 2: Separate reading from acting

The most valuable architectural move available. A component that ingests untrusted content should not be the component holding write privileges. Split them, and pass structured, validated results between them.

This single boundary neutralizes most indirect prompt injection outcomes: the injected instruction lands in a component with nothing worth stealing and nothing dangerous to call.

Step 3: Scope parameters, not just functions

“May call issue_refund” is not a policy. A policy is: may call issue_refund, for customer IDs present in the current session, for amounts under $500, during business hours, at most three times per session.

Function-level allowlists feel like least privilege and are not. The parameters are where the blast radius lives.

Step 4: Gate the irreversible

Classify every action as reversible or not. Irreversible actions—external communication, money movement, deletion, permission changes, production configuration—require human approval or a compensating control such as a delay window with notification.

Keep the gated set small and genuinely high-stakes. An approval prompt on every third action trains people to click through, which is worse than no gate at all.

Step 5: Authorize at call time

Policy that lives only in credential issuance is static. Evaluate each tool call as it happens against the current policy, the effective principal, and the provenance of the parameters. This is the control that catches the case where the credential is legitimate and the request is not.

Step 6: Measure granted vs. exercised

Instrument which permissions each agent actually uses. Anything granted and unexercised for ninety days is a candidate for revocation with near-zero operational risk. This turns least privilege from a design aspiration into a monthly maintenance task with evidence behind it.

A Worked Example

An enterprise deploys an agent to triage customer support tickets. Initial provisioning: read and write on the ticketing system, read on the customer database, the refund API, and outbound email.

Apply the budget:

  • Split it. The ingestion component reads tickets—which contain attacker-authored text—and holds nothing else. A separate action component receives a validated, structured triage result.
  • Scope it. Customer database access narrows to the requesting customer’s record. Ticket write access narrows to status, priority, and internal notes—not the customer-visible body.
  • Gate it. Refunds require agent approval above $100. Outbound email is removed entirely; the agent drafts, a human sends.
  • Constrain it. Maximum eight tool calls per ticket. No recursion into another agent.

Now consider the incident: a ticket contains an injected instruction to email a customer list to an external address. The ingestion component reads it and has no mail tool. The action component never sees the raw text. The attack produces a strange internal note and an alert, rather than a breach notification.

Where Cranium AI Fits

Capability budgets are enforced in your architecture — in the tools you grant and the credentials you issue. What makes them maintainable is knowing what exists and what is actually being used. The AI Trust Loop runs Discover, Observe, Govern, Secure, and Prove:

  • Discover AgentSensor™ enumerates agentic frameworks, agent tools and MCP servers from your source code into the AI Bill of Materials, so the envelope in Step 1 is a report rather than an archaeology project.
  • Observe Guardian’s Tool Inspector records the tool calls made during each event, and agent use cases surface top tool invocations — the exercised-versus-granted comparison in Step 6, with real numbers behind it.
  • Govern Profiles enforce your ruleset on the traffic Guardian sees: block, modify or pass, per signal, on input and output.
  • Secure Arena™ tests the model behind the agent adversarially before it ships, and Guardian Enforce acts inline on prompts and responses in production.
  • Prove A dated record of which agents existed, which tools they held and which they exercised — the evidence behind a least-privilege claim.

To be exact about the boundary: Cranium AI records tool calls, it does not authorize them. The gate belongs in your architecture. The measurement that tells you where to put it is what has been missing.

Frequently Asked Questions

Does constraining agents make them less useful?
Less capable in the abstract, roughly as useful in practice. Most agents exercise a small fraction of their granted permissions, which is exactly why the granted-versus-exercised measurement is so persuasive internally.

Is a human approval step enough on its own?
No. Approval fatigue is real—gate a narrow, high-stakes set and let policy handle the rest automatically.

How does this differ from normal least privilege?
The principle is identical. What changes is that you cannot derive the required scope by reading the code, because the caller decides its own actions. Scope has to come from observed behavior and enforced policy instead.

Where should we start with agents already in production?
Enumerate irreversible actions first. That list is short, it is the highest severity, and it is usually the fastest thing to gate.

See Cranium AI in Action

See granted-versus-exercised agent tool usage in Cranium AI—schedule a personalized demo: cranium.ai/get-a-demo/