OWASP LLM Top 10 Controls Translated Into Agent Policy
Agents need active policy controls, not passive guardrails, to enforce OWASP risks.

The OWASP Top 10 for LLM Applications gives security teams a shared vocabulary for talking about model risk, but that vocabulary was built around a single moment: a model produces a response, and a person reads it. Autonomous agents break that frame. When an agent generates a bad output, the output doesn't stop at a screen. It becomes an instruction to a tool, a call to an API, a write to a database. The harm moves from words to actions, and the blast radius grows with it.
The ranking data confirms the shift is already underway. Excessive Agency moved from sixth place in 2025 to third in 2026, which is the largest single upward jump by landing position on the list. In raw terms, Unbounded Consumption climbed even further: it jumped from tenth to sixth. Both moves point to the same cause: tool-calling agents have entered production fast, and the risks tied to what an agent is allowed to do are now outpacing the risks tied to what a model says. The list itself hasn't failed. It needs translation into something an agent architecture can actually enforce.
How Agents Structurally Differ From the LLM Applications the Top 10 Was Written For
None of these existed in a meaningful way when the first LLM risk catalogs were written, and each one stretches the reach of every item on the list.
Persistent memory means an agent's context doesn't reset between conversations. Information planted in one session can quietly shape decisions in a later one. A single prompt window used to be the outer boundary of an attack. For an agent with memory, that boundary disappears, and a compromise introduced in session one can appear as a harmful action in session three.
Chained tool calls change what a bad output actually is. In a single-response system, a bad output is a bad sentence. In an agent, a bad output triggers a sequence of tool invocations, and some of those actions can't be undone once they run.
Delegated credentials raise the stakes further. Agents operate as non-human identities, so they authenticate directly into external systems. If an attacker compromises the agent, they don't just get a bad response. They inherit every credential the agent holds and can move laterally into any system that agent was ever trusted to reach.
Multi-agent orchestration adds a problem none of the other three fully capture on their own: it breaks the chain of accountability. When a group of agents hands tasks back and forth and one of them makes a harmful decision, figuring out whether the prompt, the model, the tool, the user, or the application design caused it can be genuinely difficult. That difficulty carries legal, operational, and compliance weight, and orchestration multiplies it, because now the question isn't just what went wrong inside one agent, it's which agent in the chain made the call that mattered.
Why passive mitigations must become active, enforceable policies
Translating an OWASP control for agents means moving it from something a model is told to do to something a system forces it to do. A filter that screens prompts for suspicious phrasing is a passive mitigation. But it works only until someone finds wording the filter was never trained to catch.
Compare that to a policy that blocks a tool call from executing unless a human has approved it within the last few minutes. That's an active control, and it holds regardless of how the request was phrased, because the enforcement doesn't depend on recognizing the attack. It needs a separate, verified human action before anything irreversible can happen.
The identity and access management guidance from NHIMG states the underlying shift directly: the real question is no longer whether a model is accurate enough, but whether its identity boundaries are narrow, external, and enforceable. So authorization has to live outside the model, in deterministic systems built for access control, not inside a system prompt or a chain of model-generated reasoning. A system prompt that carries access logic is only as secure as the model's willingness to keep it secret, and once a model can reveal or infer that logic, the control is already broken.
Regulation hasn't caught up to this shift, and won't for a while. Governance frameworks move through multi-year cycles of negotiation and consensus, but agentic AI became a real deployment pattern in a fraction of that time. The frameworks that do offer direct coverage, OWASP Agentic, CSA MAESTRO, and AIUC-1, all date from 2025 or later. No compliance-tier framework carrying binding legal obligations was finalized after agentic AI existed as a deployment category. So if you're building agents today, you can't wait for those obligations to be rewritten. The policy work described in the rest of this piece has to happen regardless of where regulation lands.
Prompt injection translated: maintaining separate control planes for instructions, data, and tool responses
The agent-specific version is harder to see coming. Indirect injection happens when an agent retrieves a document mid-task, a PDF, a resume, a webpage, and that document carries embedded instructions the agent treats as commands.
Gravitee's practical guide walks through a hiring-agent scenario, and it makes the mechanism concrete. A candidate hides white-on-white text in a resume. The agent reads the resume as part of its screening task, follows the hidden instruction, and issues a positive recommendation. So the hiring manager sees a clean report and never finds out what happened. No malware, no network breach, just a document that told the agent what to conclude.
MCP-connected agents face a second version of the same problem: the tool responses themselves. A tool description can be written to instruct the agent to pull sensitive files and send them somewhere else. Invariant Labs demonstrated exactly this in April 2025 against Cursor. A tool that looked harmless carried a description instructing the agent to read the files at ~/.ssh/id_rsa and ~/.cursor/mcp.json and exfiltrate their contents. The same research team also showed a parallel attack against a WhatsApp MCP server, and it could leak a user's message history.
The fix NHIMG's guidance points to is architectural: keep instructions, data, and retrieval on separate paths, so a poisoned document never has a route to act as a hidden command channel. That principle is necessary, but it isn't sufficient on its own. Filtering catches injection patterns that have already been seen somewhere before. It won't catch a phrasing nobody has used yet. The real defense has to bound what a compromised model is able to reach in the first place, which turns prompt injection into a permissions question rather than a filtering question, and that's exactly the problem Excessive Agency is built to solve.
Excessive agency translated: least-privilege tool scoping and approval gates as the structural fix
Excessive Agency is the one OWASP risk that comes directly from how agents are built and deployed. Its fix is structural too: scope every agent's tools down to the minimum it needs, and require human approval before any irreversible action runs. That combination limits damage no matter how the compromise started, whether it was a prompt injection, a poisoned tool, or a stolen credential.
OWASP traces Excessive Agency to three root causes. With excessive functionality, the agent can reach tools well beyond what its actual task requires. With excessive permissions, the tools it does use carry broader privileges than the task calls for. With excessive autonomy, high-impact actions go through, and no human checks them first.
The clearest illustration is a customer support agent given the ability to issue refunds. A persuasive enough prompt can get that agent to approve a refund that skips every check a human agent would normally apply, not because anyone broke in, but because the agent did precisely what its tools allowed it to do. No stolen credentials, no injected code. Just a tool with more reach than the task warranted.
OWASP's own remediation is specific: run extensions in the user's actual security context instead of a generic high-privileged service identity, and make sure authorization decisions get made in an external system rather than left to the model's own judgment. NHIMG's practitioner guidance echoes the same logic from a different angle: limit each agent's tool set to what its workflow genuinely needs, require approval for any high-impact step, and verify sensitive actions through a system that sits independent of the model itself.
In policy terms, that means defining tool allowlists by agent role rather than by individual agent instance, putting approval gates on anything irreversible or financially significant, and giving each agent a durable identity separate from whatever model happens to be running underneath it, so policy can track identity rather than model version. The ranking data backs up why this matters now. Excessive Agency's jump from sixth to third is the largest climb into the top three of the entire list, even as Unbounded Consumption posted the single largest numerical move, rising four places from tenth to sixth. Incident data is already showing that agents with too much reach are causing real damage, and attributing that damage after the fact, across a chain of tools and approvals, is precisely the accountability problem that scoped identity and approval gates are designed to prevent.

Access control on agent queries and context exposure
A static model trained on the wrong data might memorize PII or credentials during training and regurgitate them. An agent introduces a new version of the same risk: it actively queries connected systems, pulls from session memory, retrieves documents, and then folds whatever it finds into a response, or hands it off to another tool entirely.
The Samsung case from 2023 still stands as the clearest example of how this goes wrong. Employees pasted proprietary source code into ChatGPT, and the system processed that code, and may have retained it. For an agent built with persistent memory, that kind of exposure is a structural feature of how the system is built to work.
System prompts often hold business logic, API endpoint references, and access credentials, and treating them as secret is insufficient because the model can reveal or infer them. NHIMG's analysis states the mechanism directly: the control becomes visible to the attacker the moment the model can reveal or infer it.
The policy fix is the same move made twice: get credentials and business logic out of the system prompt entirely and into external secret stores, referenced through scoped, time-limited tokens. Every system prompt should be treated as something that could eventually be exposed, and the rest of the system should be designed around that assumption.
Data loss prevention tools still have a role here, but they can only catch patterns they already recognize. A model can reconstruct a sensitive fact from scattered partial context without ever quoting the original source directly, and no pattern-matching filter will flag that. The actual control has to be restricting what the agent can query in the first place, not scanning what it outputs after the fact.
Supply chain translated: AI component inventories and authenticated tool manifests for every MCP server
An agent's supply chain runs wider than most teams account for. It isn't just the model and the training data anymore. Every MCP server the agent can reach is part of that chain too, and the first documented case of a malicious MCP supply-chain attack showed how little it takes for a compromised tool to slip past every existing control.
The incident centers on an npm package called postmark-mcp. A malicious version, roughly 1.0.16, quietly added a blind carbon copy of every outgoing email to an external domain. Security researchers tracked it in September 2025 as the first known malicious-MCP-server supply-chain incident. There was no credential theft and no network anomaly to catch. The tool just did something slightly different from what its manifest described.
Standard supply chain tools, dependency scanners, artifact signing, were built to catch known vulnerabilities in code. They weren't built to catch a backdoor buried deliberately in a model's weights, a dataset that looks entirely clean on inspection, or a tool that performs its advertised function correctly while it quietly does something extra on the side. That gap is why MCP tooling needs the same treatment software supply chains have slowly adopted elsewhere: an inventory of what every tool actually is, where it came from, and a signed manifest confirming it still does only what it claims. Without that, a single compromised package, like postmark-mcp, can sit inside a production agent workflow for months, doing what it was installed to do, plus one thing nobody authorized.


