OWASP Agentic AI Threat Model Breakdown
How autonomous AI agents bypass security controls designed for question-answering systems.

The OWASP Agentic AI threat model exists because agents don't just answer questions anymore; they act. They act, and the security frameworks built to judge answers can't evaluate actions the same way.
The Boundary Agentic AI Crosses
STRIDE and frameworks like it were built to check components one at a time, not to trace the chain an attacker actually walks. Each piece gets inspected on its own, and the result is a tidy pass or fail that can miss the thing that's actually happening across the whole system.
Take an enterprise AI assistant. A STRIDE review can confirm mailbox access is authenticated, RAG inputs are filtered, and tool connectors are allow-listed, and still miss the attack completely, because nothing in that chain gets broken. The system just gets walked through a sequence of legitimate states, one after another, until the outcome is theft or damage.
Three failure patterns explain why this keeps happening. Text controlled by an attacker can sit inside an agent's reasoning across multiple cycles, quietly shaping later decisions without ever tripping a single check. A chain like input, then retrieval bias, then a shift in the planning goal, then a tool call, then exfiltration, is treated by STRIDE as separate threat assessments; to the attacker, it's one path from start to finish. And often nothing gets spoofed, no authentication breaks, no binary gets tampered with. Every step runs exactly as designed, and the harm comes purely from how those legitimate steps get combined.
The EchoLeak vulnerability, tracked as CVE-2025-32711, in Microsoft Copilot shows this in production. It worked by exploiting that second pattern, cross-zone causality, stringing together components that were each sound on their own into a path that wasn't.
What actually changes with agentic systems is the surface those threats now operate on: multi-step, goal-driven, stateful execution where instructions and data stop being cleanly separable. Research from KU Leuven, IBM Research, CISPA Helmholtz Center, Imperial College London, and A*STAR, published under the name MATRA, names this directly: in agentic pipelines the line between an instruction and a piece of data blurs, and that blur is what lets an agent get steered by content it was only supposed to process. Prompt injection, in this light, works the same way code injection works on a computer: it delivers executable instructions through a channel meant only to carry input, and current defenses reduce the risk without closing it off.
The reach of that risk goes well past a single prompt and its response. System prompts, long-term memory, and RAG knowledge bases all persist, so they can all be poisoned once and exploited across sessions, long after the original interaction ends. A framework built to secure what an AI says can't account for an AI that moves money, sends communications on someone's behalf, modifies code, or calls external APIs on its own. That's the boundary this whole conversation sits on: from securing output to securing action.
How OWASP's Agentic Security Initiative arrived at a confirmed-incident taxonomy
OWASP's Agentic Security Initiative didn't start with a finished taxonomy. It started with a threat model. The first guide in the series, "Agentic AI Threats and Mitigations," came out on February 17, 2025, laying the groundwork the rest of the initiative would build on.
Ten months later, that groundwork had become something closer to an industry standard. The OWASP Top 10 for Agentic Applications was published in December 2025, built with input from more than 100 security researchers, industry practitioners, user organizations, and leading cybersecurity and generative AI technology providers. That breadth of contribution is what makes it the first standardized taxonomy of agentic risk rather than one vendor's or one lab's opinion.
The GenAI Security Project draws contributions from a wide international base of participants, and the Agentic Security Initiative is the stream responsible for agent-specific guidance within that larger effort. On June 1, 2026, the GenAI Security Project released version 2.01 of its "State of Agentic AI Security and Governance" report, a substantial update to the first edition that reframes agentic risk around evidence instead of speculation.
That reframing carries a specific argument. Security teams used to treat AI safety, meaning harm from an agent operating normally, and AI security, meaning harm from someone crossing a trust boundary, as two separate problems requiring two separate governance tracks. Version 2.01 argues that distinction has collapsed, because both pathways can produce the exact same outcome, and both now need one governance structure instead of two.
The taxonomy organizes threats under five structural domains, marking where in a system each risk actually originates: Agent Design, Agent Memory, Planning and Autonomy, Tool Use, and Deployment and Operations. That structure matters because it tells a security team where to put a control, pinpointing the actual source of each risk.
None of this reads as theoretical anymore. By mid-2026, real incidents had already confirmed the categories. In November 2025, Anthropic disclosed that a Chinese state-sponsored group called GTG-1002 manipulated Claude Code to attempt espionage operations against roughly 30 global targets; it succeeded in a small number of cases, and the coding assistant carried out the attack at a high degree of autonomy. In December 2025, researcher Ari Marzouk documented over 30 vulnerabilities across more than ten AI coding tools in findings he called "IDEsaster". The Responsible AI Institute's TrustX ARC framework, published in July 2026, catalogued the same pattern continuing: persistent prompt injection and multi-stage attacks executing with little to no human involvement. This is a confirmed-incident taxonomy because every category in it has already happened somewhere, to someone, in production.
ASI01 through ASI05: the five threat categories rooted in how agents plan and act
The first five categories describe what happens once an agent's own goal-pursuit, autonomy, and tool access become the thing an attacker targets.
ASI01, Agent Goal Hijack, merges prompt injection with excessive autonomy: an attacker injects instructions that redirect what the agent is trying to do, and because the agent executes across multiple steps, the effect compounds far past what a single bad response could cause. It differs from classic prompt injection in one important way. The agent's planning loop lets a redirected goal persist across many reasoning cycles on its own, so the attacker doesn't need to come back and reinforce it.
ASI02, Tool Misuse and Exploitation, covers agents that call tools in a sequence where each individual call is authorized, but the sequence as a whole achieves something nobody authorized. It's abuse of legitimate functionality happening at the level of composition rather than any single call.
ASI03, Identity and Privilege Abuse, exploits misconfigured roles, credentials, access control lists, trust relationships, or flawed delegation logic to gain elevated permissions. Agents tend to accumulate permissions over time, and those permissions rarely get revoked once an agent is decommissioned or repurposed, turning this into an ongoing governance failure rather than a one-time setup mistake. When several agents share one service account, attribution breaks down entirely: an organization can't investigate which agent did what, can't apply different permissions to different agents, and can't disable one without knocking out the others.
ASI04, Agentic Supply Chain Vulnerabilities, opens before a single tool call even happens. Malicious instructions can enter an agent's context through a tool's description or metadata. The clearest case of this in production is the Postmark incident from September 2025. A copycat email MCP package impersonating the legitimate Postmark MCP server was published on npm, and it silently BCC'd every email an agent sent to an attacker-controlled domain. The opening came the moment the poisoned tool description entered the model's context, and the damage compounded because that MCP server carried elevated privileges across multiple connected systems. Supply chain risk in agentic systems scales this way by nature: one compromised tool can touch every agent that discovers and loads it, not just the one that installed it first.
ASI05, Unexpected Code Execution, happens when agents with code-generation or execution abilities get steered into running a payload the attacker controls, and often the agent never recognizes it has wandered off its intended task. The "IDEsaster" findings from December 2025 showed exactly this: third-party files manipulating coding assistant outputs across widely deployed developer tools. Sandboxing and network isolation are the standard architectural defenses here, but how well they work depends entirely on how tightly the execution environment gets scoped.
ASI06 through ASI10: the five threat categories that only exist in multi-agent and persistent systems
The second half of the taxonomy covers something the first half doesn't: threats with no equivalent anywhere in traditional LLM applications. These five only exist if an agent holds memory across sessions, talks to other agents, or runs without a human checkpoint in the loop.
ASI06, Memory and Context Poisoning, works by corrupting an agent's memory so that future sessions inherit the damage. The harm doesn't land in the session where the poisoning happens; it lands later, in whatever the agent carries forward. Long-term memory stores, RAG knowledge bases, and system prompts all persist, which makes them targets for compromise that survives well past the original session. MATRA's research flags this as a long-horizon attack vector, making a point worth sitting with: the riskiest moment often isn't the current tool call, it's what gets left behind in state.
ASI07, Insecure Inter-Agent Communication, occurs when agents pass tasks, results, or context to each other. A compromised upstream agent can inject instructions straight into a downstream agent's context, and the downstream agent has no way to verify where those instructions actually came from. Authentication between agents is rarely enforced at the protocol level at all; most setups simply inherit whatever trust the orchestration framework hands out by default. OWASP flags this category as having no analog in traditional LLM security, because it requires agent-to-agent trust models that most governance frameworks in use today haven't built yet.
ASI08, Cascading Failures, describes what happens when one agent's mistake doesn't stay contained. An agent acting on bad input or compromised context hands that bad artifact to the next agent in the workflow, and the failure spreads across systems, tools, and processes, sometimes causing unauthorized actions, data exposure, or financial loss before any human notices the deviation.
ASI09, Human-Agent Trust Exploitation, covers an agent exploiting the trust a human places in it, producing output that leads a person to authorize something they never would have approved with the full picture in front of them. This is distinct from goal hijack, because the human hasn't been bypassed, they're still in the loop; they're being steered by how the agent presents what it's done. Human review checkpoints aren't enough on their own if the agent controls what the human gets shown before making the call.
ASI10, Rogue Agents, is where the previous nine categories end up if nothing catches them, operating outside the scope it was given, whether because it was designed loosely, its goal representation drifted over time, or it was manipulated into pursuing objectives its operators never authorized. It's the result of upstream failures stacking up: weak goal specification, no runtime monitoring of intent, no kill switch that actually works. OWASP's maturity model names Level 3, Integrated and Continuous Oversight, as its highest governance tier, the point where agentic AI gets managed like critical infrastructure, with working kill switches and real-time anomaly detection built in to catch exactly this category before any harm happens.
MCP's Protocol-Level Gap and the Top 10 Categories
The Model Context Protocol doesn't enforce security at the protocol level, and that single gap gives every OWASP category involving tool use or agent-to-agent communication a concrete path into any MCP-connected deployment.
MCP standardizes how a model discovers tools and calls them. The MCP specification standardizes how models discover and call tools but leaves authentication, authorization, and transport security to whoever implements each host, client, and server, making the gap structural rather than a bug in any particular implementation.
The Postmark incident is what that gap looks like once someone exploits it. A copycat MCP package sat on npm impersonating a legitimate tool, and because MCP doesn't verify tool identity at the protocol level, nothing stopped it from reaching agents that trusted it. The same structural absence runs under ASI04's supply chain risk, ASI02's tool misuse, and ASI07's inter-agent communication risk: in each case, the protocol assumes good faith where it should be checking for it.
This is the connective thread running under the entire Top 10. The taxonomy names ten ways agentic systems fail. MCP, as the most common way agents actually discover and call tools in production, is where a large share of those failures find their way from a theoretical category into an actual incident. Closing that gap means building authentication, authorization, and transport security into how MCP gets implemented, since the protocol itself won't do it by default.
Sources
- Agentic AI - OWASP Lists Threats and Mitigations
- MATRA: Modeling the Attack Surface of Agentic AI Systems -- OpenClaw Case Study
- OWASP’s Agentic AI Maturity Model: A CISO Guide
- TrustX Agent Risk Classification Framework (ARC): Risk-Tiering Internally Created Agentic AI Systems
- Parallax: Why AI Agents That Think Must Never Act
- genai.owasp.org
- Model Context Protocol (MCP) Security


