LetterMCP

OWASP Top 10 for Agentic Applications 2026

AI agents with real credentials and tools face new security risks that go beyond chatbots.

· 9 min read · Updated
Cover illustration for “OWASP Top 10 for Agentic Applications 2026”
Agent Security · August 7, 2026 · 9 min read · 2,050 words

The OWASP Top 10 for Agentic Applications 2026 names a risk surface that has nothing to do with a model writing a bad sentence. It names what happens when an agent takes a bad action with real credentials, real tools, and real downstream consequences. The list was published December 9, 2025, by the OWASP GenAI Security Project, built by more than 100 security experts, researchers, and practitioners, and it was drawn from incidents that had already happened, not from speculation about what might.

The existing OWASP Top 10 for LLM Applications was built for a simpler system: something that receives input and produces output. An agent is a different kind of thing: it has goals, credentials, tools, memory, and the ability to act across many steps without a human checking each one. Four properties set agentic systems apart from chatbots: they make autonomous decisions across multi-step plans, they carry persistent memory across sessions, they invoke tools and APIs dynamically, and they coordinate with other agents under delegated authority. None of those properties exist in a standard chatbot, so none of the risks they create were covered by the earlier list.

A single idea runs through the list: an agent's exposure equals every credential, tool, and API it can reach, and the damage from a bad decision compounds across a whole plan rather than stopping inside one response. Agentic security has to solve for how far damage can spread from a single compromised agent, and it is why the list's categories are numbered ASI01 through ASI10, a prefix that marks a separate taxonomy rather than a subset of the LLM risks that came before. Each category that follows builds on that same premise: the agent isn't just generating language anymore, it is acting.

ASI01 (Agent Goal Hijack), how an agent's instructions become the attack surface

A flaw cataloged as CVE-2025-32711 and scored 9.3 on the CVSS scale, known as EchoLeak, showed what goal hijack looks like in production. Known as EchoLeak, the attack planted hidden instructions inside a crafted email; Microsoft 365 Copilot retrieved that email as context, then exfiltrated data from the user's environment, and no click was needed beyond the user invoking Copilot in the first place. It is the first confirmed zero-click attack on a production AI agent.

Goal hijack works because an agent redirected toward a new objective keeps all its legitimate tools and permissions and simply points them somewhere else. The sources describe four ways this happens: direct goal manipulation through explicit prompt injection, indirect instruction injection hidden inside documents, retrieved content, or tool outputs, recursive hijacking that spreads through a chain of reasoning steps, and cross-context injection, where instructions planted in one session shape behavior in a session the attacker never touched. In each case, the agent is following instructions. The instructions just didn't come from where it thought they did.

This is a problem application security has no existing answer for. Traditional controls check whether a request is authorized or whether input is malformed, but nothing in that toolkit asks whether the plan itself has been quietly swapped out for a different one. Each step in a hijacked chain can look completely reasonable on its own. The chain as a whole executes an objective nobody approved. Agents process natural language, so the system has no reliable way to tell a legitimate system instruction apart from a malicious payload sitting inside retrieved content.

ASI02 (Tool Misuse and Exploitation), when legitimate permissions become the weapon

Goal hijack explains how an agent gets redirected, and tool misuse explains what it then does with the access it still holds. In July 2025, an attacker exploited an inappropriately scoped GitHub token to commit a malicious prompt into version 1.84.0 of the Amazon Q Developer extension, which had more than 950,000 installs at the time. The prompt instructed the agent to "clean a system to a near-factory state," and the agent proceeded to delete local files and cloud resources using its own legitimate AWS CLI tools. A syntax error prevented the attack from executing in full, and AWS shipped a clean version, v1.85.0.

The agent held valid permissions. It called tools through their documented interfaces. The authorization system watching over it saw a sequence of calls it had every right to make. The catastrophe happened anyway.

Four sub-patterns describe how this plays out: recursive tool calls that exhaust resources, unsafe tool composition where tools get chained together in sequences no designer ever anticipated, tool budget exhaustion from automated abuse at scale, and cross-tool state leakage, where information moves unsafely from one tool's context into another's. The common thread across all four is that authorization systems are built to answer one question: can this agent call this tool? None of them are built to answer whether this agent should call this tool, in this sequence, for this purpose. The Amazon Q incident shows exactly that gap: a token with too much scope, attached to an agent with no mechanism to ask whether a factory-reset instruction made sense before carrying it out.

ASI03 (Identity and Privilege Abuse), why agents are not service accounts

A service account sits in one system, holds one credential, and does one job. An agent does nothing of the sort. It acquires permissions dynamically at runtime, spawns sub-agents, calls external APIs, writes and runs its own code, and chains actions across dozens of systems within a single task. Its authority doesn't have a fixed perimeter, and it can't be governed the way a human account can be governed.

That mismatch is visible in the data. Analysts looked at 77 publicly disclosed vulnerabilities, and one in three agent framework flaws turned out to involve an identity, credential, or access control weakness. Most identity systems in production today were built for humans who log in once, and for static services that hold one credential for the long haul. Neither model fits something that reassigns its own scope mid-task.

Closing that gap calls for a different starting principle than the one most deployments use today: autonomy should be earned rather than assumed by default, which means the live question isn't just what an agent can reach, but how much freedom it has to act on that access without checking back first. In concrete terms, that means giving each agent its own managed identity, with its own client ID and secrets restricted to non-human tasks, issuing short-lived credentials scoped only to the current step, and building in rapid revocation that can cut an agent off without touching the human user's session. Few deployments have all three in place today, and that gap is a large part of why identity and credential flaws keep appearing in vulnerability disclosures.

ASI04 (Agentic Supply Chain Vulnerabilities), the MCP ecosystem as attack surface

An agent doesn't just trust its own code. It trusts every tool, server, and protocol it connects to, and it extends that trust at runtime without checking it again. That is what makes the agentic supply chain more dangerous than the software supply chain security teams are used to defending: a single poisoned tool description is enough to redirect behavior, no breach of the agent itself required.

Three attack variants share that structural root. Tool description poisoning hides malicious instructions inside a tool's own metadata. A server can behave one way while a client builds trust in it, then change that behavior afterward; that's a rug-pull attack. A malicious tool can intercept or override a legitimate one the agent believed it was calling; that is tool shadowing. The Model Context Protocol has no built-in authentication or authorization, and adoption has outpaced the security controls needed to secure it: by early 2026, security researchers had catalogued nearly 7,000 internet-exposed MCP servers, and roughly half of them were running with no authentication controls at all.

That gap has already produced real incidents. Straiker's AI Research (STAR) Labs documented the SmartLoader campaign, in which an MCP server was used as a malware delivery vehicle. A vulnerability cataloged as CVE-2026-33032, nicknamed "MCPwn" and scored 9.8 on the CVSS scale, allowed an authentication bypass that was actively exploited before being patched on March 15, 2026. Wiz Research disclosed two flaws in the Amazon Q VS Code extension: CVE-2026-12957, which let MCP configurations auto-execute without user consent, and CVE-2026-12958, a companion symlink and path-traversal vulnerability. Together they let a malicious repository achieve arbitrary code execution and steal cloud credentials, because the MCP server processes an agent spawned had inherited the full developer environment around them. That same flaw is the one Amazon Q exposed earlier in the year through its GitHub token, now exploited again through a different door.

Dozens of CVEs were disclosed against MCP implementations across 2026 alone, and researchers estimate hundreds of thousands of vulnerable servers remain exposed globally. The category maps directly onto EU AI Act Article 25, which addresses value-chain responsibility, so regulators now have a concrete hook for exactly this kind of exposure.

ASI05 (Unexpected Code Execution), when the agent writes and runs its own instructions

An agent that writes and executes its own code or shell commands is a runtime code interpreter, and its output goes straight into execution, bypassing every review step that software engineering has spent decades building.

The attack scenarios that follow from that are varied but share the same shape: a DevOps agent compromised through a generated script carrying hidden commands, a workflow engine exploited by an AI-generated script with a backdoor built in, an attacker crafting a data exfiltration command by exploiting the agent's own language processing, or a sandbox escape achieved through code the agent generated itself. The Amazon Q VS Code case from June 2026 shows this mechanism concretely: the spawned MCP server processes inherited the full developer environment, handing an attacker immediate access to cloud infrastructure the moment a crafted workspace configuration triggered code execution.

Traditional code review, static analysis, and dynamic analysis tools all assume a pipeline: code gets written, then reviewed, then run. If an agent generates and executes code in the same step, those tools have no point left where they can insert themselves. The Amazon Q extension, with more than 950,000 installs at the time it was compromised, makes that gap concrete rather than theoretical. To close it, you need sandboxed execution environments with real blast-radius isolation, execution boundaries that treat anything the agent generates as untrusted by default, and shell access denied unless a task explicitly requires it.

ASI06 (Memory and Context Poisoning), attacks that arrive clean and detonate later

Every category up to this point involves an attack and a consequence that happen close together. Memory poisoning breaks that pattern. The session where the attack actually lands looks completely clean, and the manipulated behavior appears only later, in a conversation that has nothing obviously to do with the original compromise.

That delay is possible because agents are built to carry context across sessions. Content processed once can get written into persistent memory, and that memory then shapes how the agent reasons in every future session, including ones the original attacker never touches. OWASP maps a documented case directly to this category: research demonstrated that hidden instructions inside processed content could write false long-term memories into a production assistant, Gemini, quietly steering its behavior in later conversations that had no apparent connection to the original attack.

Beyond poisoning a retrieval-augmented generation pipeline directly, the sources describe related patterns: gradual memory poisoning through repeated interactions that each look harmless on their own, exploiting the limits of an agent's memory so it fails to recognize a privilege escalation in progress, and corrupting shared memory inside a multi-agent system so the corruption spreads across the network. Each variant depends on the same weakness: memory is trusted by default once it's written, regardless of how it got there.

Detecting any of this after the fact is harder than it sounds. Audit logs record what an agent did, but they don't automatically point to which memory state caused it to do that. A 2026 industry survey found that 67% of enterprises have AI agents deployed without comprehensive audit logging in place at all. For a category of attack defined by the gap between when it lands and when it detonates, that absence of logging decides whether a compromise gets caught or never comes to light.

Sources

  1. OWASP Top 10 for Agentic Applications (2026) — Modulos Governance Guide
  2. genai.owasp.org
  3. genai.owasp.org
  4. genai.owasp.org
Filed underAgent Security

More in Agent Security