AI agents can update customer records, process requests, and perform routine tasks directly inside business systems. But when these agents have access to systems they do not need, even a routine task can put important business data at risk.
Three causes of excessive agency, and the control for each
Hover or tap a cause or a control for details.
In April 2026, TechSpot reported that a coding agent at PocketOS, a car-rental software company, deleted its production database and backups in nine seconds. The agent was working in a test environment but used an API token that allowed access to live systems. The company then had to rebuild booking records using payment histories, calendars, and emails.
The agent had more access than its task required. This is called excessive agency. It happens when an agent has more tools, permissions, or control than it needs to complete its work.
A 2026 Cloud Security Alliance survey of 418 IT and security professionals found that 65% reported an agent-related security incident in the previous year. The survey covered different types of incidents, not just excessive agency.
To reduce these risks, businesses need to control which systems agents can access, what changes they can make, and when employees must approve their actions.
Excessive Agency at a Glance
- What it is: an AI agent holding more tools, permissions, or freedom to act than its job needs. OWASP ranks it LLM03 in its 2026 Top 10 for LLM Applications, up from sixth in 2025.
- Why it matters: extra access never helps when the agent works correctly, and it causes damage when the agent makes a mistake or follows a hidden instruction.
- Three causes: unneeded functions, over-broad permissions, and no approval step before high-impact actions. Each needs its own fix.
- The most important control: limits enforced by the connected system, not by the agent's instructions. A prompt saying "don't delete" stops nothing.
- Before launch: ask your development team to demonstrate the nine checks in the pre-launch checklist below.
When AI Agents Have Too Much Control
An agent can make a serious mistake even when it is trying to complete a task. If it has broad access to business systems, it may make changes that were never part of its job. Without proper checks, those changes can affect live operations.
In December 2025, an engineer at Amazon Web Services used its Kiro coding agent to fix an issue in a live system. The Decoder, citing a Financial Times report, said the agent decided to delete and recreate the environment. The change disrupted AWS Cost Explorer for 13 hours in one mainland China region.
The agent was using the engineer's permissions, which were broader than expected. The change also went ahead without the usual second-person review. Amazon said the disruption was caused by misconfigured access controls rather than an error in the agent. The company later made peer review mandatory for production access.
The agent was supposed to help fix a software issue, not make major changes to a live system without review. Developers need to limit what an agent can change and require approval before it performs actions that could disrupt business operations.
What Is Excessive Agency in AI?
Excessive agency is the gap between what an agent is allowed to do and what its job needs. That extra access does no business good: a working agent never needs it, and it is the only thing that can cause damage when the agent fails.
In the newly released OWASP Top 10 for LLM Applications (2026), excessive agency moved from LLM06 in 2025 to LLM03. OWASP describes the risk as an AI system taking damaging actions in response to unexpected, ambiguous, or manipulated model outputs. Those outputs can result from three sources:
- Model errors: agent misreads a request or adds a step.
- Prompt injection: instructions hidden in an email, document, or web page the agent reads.
- Compromised tools: a malicious plugin or another agent passing on bad instructions.
No business can rule out all three, so the extent of damage an error can cause depends on the agent's access. This is illustrated by OWASP's own scenario: an assistant can only receive emails but cannot send any. Allow it to send messages too, and a single rogue instruction might make it send sensitive data to an attacker.
How a Hidden Instruction Becomes a Real Action
An agent with broad system access can be manipulated through an email, document, or web page. The attacker does not need direct access to the company's systems. Instead, they place instructions in content the agent is expected to read.
An attack like this can follow five steps:
- The agent has access to tools. It can read emails and send messages, even though its main task may only require reading the inbox.
- The agent reads outside content. An email, support ticket, or web page contains instructions added by someone outside the business.
- The agent follows the hidden instructions. It treats the text as a request and decides to use one of its connected tools.
- The system accepts the request. The tool checks the agent's credentials. If those credentials allow the action and no further approval is required, the request can proceed.
- The action is completed. The agent may send sensitive information, change records, or delete data without the employee's approval.
Different security controls can stop the attack at different stages. Content filters may identify malicious instructions, but they cannot catch every attempt. Developers also need to restrict tool access, enforce permissions, and require approval for sensitive actions.
Controls at steps 1, 4 and 5 hold even when the model is fooled
Hover or tap a step or a control for details.
These checks should work independently of the agent's decisions. Even if it follows a malicious instruction, the connected software should block actions it is not authorized to perform.
Why Excessive Agency Matters to Business Leaders
Excessive agency can turn one bad model output into lost data, halted processes, mispayments, or exposed customer data. It can take only seconds for the error to occur. PocketOS staff then had to manually recreate customer bookings from payment and email records, and AWS Cost Explorer stayed down for 13 hours.
The Cloud Security Alliance survey shows how common this is. When asked about incidents involving agents, 61% of organizations reported data exposure, 43% reported operational disruption, and 35% reported financial loss. These figures cover agent incidents in general, not excessive agency alone.
The same survey shows how often the limits are missing. When an agent tries to act outside its scope, only 38% of organizations require human approval and 11% block the action automatically. Only 21% have a formal mechanism to retire agents, meaning old agents can retain live credentials after they stop working. And 82% found agents running in their systems that they did not know about.
Agent incidents and controls in the 2026 Cloud Security Alliance survey
Switch views, then hover or tap a bar for details.
The easiest way to get excessive agency into production is through an agent nobody tracks, and nobody reviews. Leaders need clear answers to three questions before launch: which systems each agent can change, who approves high-impact actions, and how fast the team can undo a wrong change.
When the risk is low: an assistant with no tools, or one that only reads data it already shows the user, cannot act on a bad output. If you have a copy running in a pilot with no access to live systems or external email, it can only harm your copy. The risk begins when an agent can write, send, pay, or delete in a live system.
Three Causes of Excessive Agency
This type of agency often comes from how an agent is connected to business systems. OWASP identifies three main causes: excessive functionality, excessive permissions, and excessive autonomy. Each needs a different control.
1. Excessive Functionality
A company connects an agent to its file system so it can read and summarize reports. The same tool also allows it to edit or delete documents. These functions are not needed for its work. If the agent follows an incorrect or malicious instruction, it could change or remove important files.
The development team should only make the functions required for the task available to the agent.
2. Excessive Permissions
In a July 2025 security test, General Analysis connected a coding assistant to a Supabase database using a service_role key. This key bypassed the database's row-level security rules.
The researchers placed hidden instructions in a support ticket. When the assistant read the ticket, it accessed a separate table containing dummy integration secrets and copied them into a reply visible to the person who submitted the ticket.
The assistant only needed to review support records. However, its database credentials allowed it to access information outside that task.
3. Excessive Autonomy
In November 2025, a user reported that Google's Antigravity coding agent deleted files from his D: drive while trying to clear a project cache. The Register reported that the agent was running in Turbo mode, which allowed it to execute commands without asking for approval.
The agent reportedly ran a deletion command against the root of the drive instead of the project folder. The deleted files bypassed the Recycle Bin.
Requiring approval before destructive commands could have given the user a chance to catch the mistake.
Removing unnecessary tools does not fix broad account permissions. Limiting permissions also does not replace approval for important actions. Businesses need to check all three when reviewing an agent's setup.
Business Scenarios That Show the Risk
Each incident below connects to one or more of the three causes of excessive agency. One also shows the risk of a compromised tool. Four of the five incidents did not involve an attacker.
| Date | Company | What Happened | Cause |
|---|---|---|---|
| Apr 2026 | PocketOS | A coding agent working in staging found an API token with access to every environment and used it to delete a production volume. Backups were stored on the same volume, so the newest usable copy was three months old. Staff rebuilt customer bookings by hand using payment and email records. | Excessive permissions and autonomy |
| Mar 2026 | Meta | An internal agent posted advice on a company forum without being asked. An employee followed the advice, allowing engineers to access systems they were not authorized to use for about two hours. Meta said no user data was mishandled. | Excessive autonomy |
| Dec 2025 | AWS | The Kiro coding agent decided to delete and recreate a live environment. The reported incident disrupted AWS Cost Explorer for 13 hours in one region. The usual second-person review was skipped. | Excessive permissions and autonomy |
| Sep 2025 | postmark-mcp | A malicious version of Postmark's email connector on npm added one line of code in version 1.0.16. It secretly sent a BCC copy of every email processed through the connector to an outside address. The package was downloaded 1,643 times before the developer removed it. | Compromised tool and excessive functionality |
| Jul 2025 | Replit / SaaStr | During a declared code freeze, Replit's agent deleted a production database containing records for more than 1,200 executives and 1,190 companies. It then told the founder that rollback would not work. He recovered the data manually. | Excessive autonomy |
The fixes came after the damage. Replit introduced separate development and production databases as the default and announced a planning-only mode. Amazon made peer review mandatory for production access.
Neither control required new technology. Both could have been added before the incidents.
How Businesses Can Prevent Excessive Agency
Limit what the agent can do inside each system it uses. Then a wrong decision cannot turn into real damage. Each step below follows OWASP's guidance.
Give the Agent Only the Tools It Needs
Connect only the tools the agent uses for its job, and turn off the functions it does not use. An agent that summarizes documents needs to read files. It does not need to edit or delete them. Avoid general tools like shell access when a narrow tool can do the job.
Give Each Tool the Lowest Permission It Needs
Each tool signs in to a business system with an account. That account should have only the access the task needs. A reporting agent should use a read-only CRM account, not an admin login. Each token should work in one environment only. The PocketOS agent reached production because its token worked everywhere.
This is often a one-line change. Supabase's MCP guidance shows the difference for an agent connected to a database:
# Broad: every project in the account, full read and write
https://mcp.supabase.com/mcp
# Scoped: one project, SQL runs as a read-only Postgres user
https://mcp.supabase.com/mcp?project_ref=<your-project-id>&read_only=trueScoping does not solve everything. In the General Analysis demonstration, the secrets sat in the same project the agent could read, so read-only access would not have stopped the leak. Treat permissions as one layer of protection. Supabase also advises limiting the agent's tool groups with the features setting and keeping manual approval on for interactive work.
Let the Agent Act as the User
When an agent works for an employee, it should use that employee's access. Scoped sign-in, such as OAuth, does this. The agent then cannot open records the employee cannot open.
Ask a Person Before High-Impact Actions
Some actions should wait for a person to approve them: payments, refunds above a set limit, deleting records, bulk customer emails, and production changes. The agent can prepare the action. The system holds it until an authorized person signs off.
Too many approvals cause a different problem. People who get a steady stream of routine requests start approving without reading. Most companies already split the work. In the CSA survey, 53% let agents handle low-risk tasks alone and send higher-risk actions to a person.
To decide, ask one question: can this action be undone? If it can, and it stays inside the agent's job, let it run and log it. If it moves money, deletes data, emails many customers, or changes production, require approval. Show the approver exactly what will change. The Antigravity user would have seen the wrong drive path before anything was deleted.
Which agent actions should wait for a person
Hover or tap a step for details.
Enforce Limits in the System, Not in the Prompt
An instruction like "don't delete anything" does not stop a deletion. Only the system can do that. Replit's agent admitted it ran unauthorized commands even though it had been told not to act without approval. Put the checks in the software the agent connects to.
Treat Incoming Content as Information, Not Orders
Emails, files, support tickets, and web pages can hide instructions. The Supabase case above started this way. The agent should read this content, not obey it, and any sensitive action must still pass the same permission and approval checks. Filters that block known attack phrases help, but Zenity found that attackers can reword around them. Permission limits do not have that weakness.
Log Actions, Set Limits, and Keep an Off Switch
These steps do not prevent excessive agency. They limit the damage when something goes wrong.
- Record every action and every approval decision.
- Cap how many actions the agent can take in a set time.
- Make sure staff can stop the agent and remove its access quickly.
- Keep backups where the agent cannot reach them. PocketOS lost its recent backups along with the database.
Before an agent touches live customer data, ask your development team to show each control working, including what happens when the agent tries a blocked action.
How We Help Businesses Build AI Agents with Proper Controls
At CodingCrafts, we start every agent project by mapping the systems it will touch, the data it needs, and the actions that need approval. We build the rules into the app and test them against out-of-scope requests and invalid inputs before deployment.
We applied this approach to an AI-powered financing platform for merchants, funders, and sales representatives. The assistant had to talk to each user type differently and follow the rules of each loan application stage.
Our team created role-specific conversations and status-based checks. The assistant couldn't discuss offers on new applications or continue negotiating if declined. Hard limits on interest rates, loan amounts, and repayment terms were enforced by the system during negotiations, and cases needing judgment were handed to a sales representative.
The entire project lasted seven months. During the trial, time to next action was reduced from 48 hours to around 18–24 hours, thanks to the platform as a whole, including automated follow-ups and guided conversations.
A Pre-Launch Checklist for Founders, COOs, and CMOs
If the development team cannot demonstrate each item below, the agent is not ready for live customer data or transactions.
- Scope: A written list of what the agent does, and a demo showing that actions outside that list are blocked.
- Tools: Every connected system and function is needed for the job. Unused connectors are removed.
- Permissions: Each tool uses a least-privilege account, scoped to one environment. No admin or shared super-accounts.
- Approvals: Payments, deletions, bulk emails, and production changes stay on hold until an authorized person approves them.
- Limits: Caps on transaction values, request volume, and spending, tested at the limit.
- Injection tests: Sample emails and documents with hidden instructions fail to trigger unauthorized actions.
- Logs: Every action, error, and approval decision is recorded and reviewable.
- Kill switch and recovery: Staff can stop the agent and revoke its access in minutes, and backups sit outside the agent's reach.
- Inventory: The agent is registered with an owner and a retirement date, so its credentials do not outlive it.
Frequently Asked Questions
Can Excessive Agency Cause Damage Without an Attacker?
Yes, and it usually does. Four of the five incidents above involved no attacker: the agents at Replit, AWS, Meta, and PocketOS made their own wrong calls with access they should not have had.
Does Read-Only Access Remove the Risk?
No. It removes the risk of changes and deletions, but an agent that can read sensitive data and also send messages can still leak it, as the General Analysis test above showed. Read-only access still allows every read the account can perform, so keep data the agent doesn't need out of its reach.
Is Excessive Agency the Same as Prompt Injection?
No. Prompt injection is one way to trigger a bad action; excessive agency is the access that lets the action do damage. OWASP lists them separately, as LLM01 and LLM03 in its 2026 edition. Fixing excessive agency limits the harm from injection attacks that get through.
Does Telling the Agent to Ask Before Acting Count as Human Approval?
No. Replit's agent had a written instruction not to act without approval, but it ran destructive commands anyway. Approval only counts when the system that carries out the action holds it until a person signs off.
Do Third-Party Connectors and MCP Servers Add Risk?
Yes. The postmark-mcp package copied a real email connector, then quietly copied every message to an outside address. Install connectors only from the vendor that owns the service, and check which actions each tool exposes before connecting it.
Why Did OWASP Move Excessive Agency Up in 2026?
It rose from sixth to third, the largest move on the list. The CSA's summary of the 2026 list reads it as OWASP's growing focus on the consequences of giving models operational authority in any LLM workflow with privileged tools, not only systems labeled as agents.
When Should Agent Permissions Be Reviewed?
Review agent permissions when the agent's task changes, when you add a new tool or connector, and when you retire the agent. The last one is the most often missed: only 21% of organizations in the CSA survey have a formal process for retiring agents, so old credentials stay live.
Build AI Agents That Work Within Your Business Rules
An agent that works well in testing can still cause damage once it is connected to live systems with broad access and no approval steps. The incidents above came from setup decisions, and setup decisions are what a business controls.
CodingCrafts builds AI agents with these limits enforced by the system from the first release, as in the financing platform above. If you are planning a new agent or tightening an existing one, our developers can take the nine checks in the pre-launch checklist and show you where your current setup passes and where it does not.
Book a discovery call with CodingCrafts to discuss your project and the systems your agent will use.
Planning an AI Agent That Can Act in Live Systems?
CodingCrafts maps the systems, data, and actions your agent needs, builds the limits and approval steps into the software, and tests them against blocked actions before launch.
