ASI codes refer to categories in the OWASP Top 10 for Agentic Applications 2026. The ten risks here are an editorial grouping informed by that list, not OWASP’s own ten, and the mappings are approximate.
The 10 AI Agent Security Risks
Each risk is labelled by the kind of evidence behind it. Documented incident: publicly reported and acknowledged or fixed by the vendor. Researcher demonstration: shown to work in a controlled test, with no known real-world exploitation. Framework-identified risk: recognized by OWASP or vendor guidance, with no specific public incident cited here. Illustrative scenario: a hypothetical example.
1. Prompt Injection and Agent Goal Hijacking
Prompt injection occurs when an attacker embeds instructions in content a model processes, so the agent follows them instead of, or in addition to, its intended task. Direct prompt injection happens when the attacker talks to the agent itself and tries to override its instructions. Indirect prompt injection hides instructions in content the agent handles on someone else’s behalf: an email, a document, a web page, a support ticket or the output of another tool. Microsoft’s security response team notes that indirect prompt injection is one of the most widely used techniques in the AI vulnerabilities reported to it, and that it is the top entry in the OWASP Top 10 for LLM Applications 2025. OWASP’s agentic list describes the wider consequence as agent goal hijack: the agent’s objective is redirected, and it then uses its own legitimate access to carry out the attacker’s plan.
Evidence status: Documented incident. In June 2025, researchers at Aim Security disclosed “EchoLeak” (CVE-2025-32711), a zero-click vulnerability in Microsoft 365 Copilot. A crafted email could lead Copilot to exfiltrate data from its context without the user doing anything. Microsoft rated it Critical (CVSS 9.3) and reported it as already addressed, with no customer action required.
Illustrative scenario (not a documented incident). An agent that summarizes incoming support tickets could meet a ticket containing hidden text telling it to forward customer data to an external address. If the agent does not distinguish the ticket’s legitimate content from embedded instructions, it may act on both.
Why it is hard to fix completely. Microsoft pairs probabilistic defences (hardened system prompts, a technique called Spotlighting, and a classifier called Prompt Shields) with deterministic ones, such as blocking known data-exfiltration methods. Prompt injection is not unsolvable, but it has no single complete fix, which is why layered controls matter more than any one filter.
Mitigations. Treat retrieved content as data, not instructions. Limit what a hijacked agent could do: least privilege, scoped tools and approval for high-impact actions. Restrict outbound channels (links, images, email, pull requests) that could carry data out. Use injection detection as one layer, not as the control. Test with indirect-injection scenarios, not just direct ones.
2. Tool Misuse
An agent’s tools (database functions, email clients, file-system access, cloud APIs, ticketing systems, code environments, financial systems) extend it well beyond text generation. Tool misuse occurs when an agent is manipulated, or simply misdirected by an ambiguous instruction, into using a legitimate tool in a harmful way: running a destructive database query, emailing unauthorized recipients or changing records it should not touch. OWASP’s agentic list names tool misuse and exploitation as its second category.
The important shift is conceptual: tool permissions are part of the security boundary. A tool with more capability than the task requires is a standing risk, however well the model behaves.
Evidence status: Framework-identified risk. The destructive-query example above is illustrative.
Mitigations. Inventory every tool and approve it explicitly. Scope each tool to the minimum, read-only wherever possible. Validate parameters before execution and allow-list permitted operations. Require human approval for destructive or irreversible actions. Log every tool call.
3. Excessive Privileges, Weak Agent Identity and Credential Exposure
Broad, standing permissions are one of the most common and most avoidable sources of agent risk. An agent granted admin-level database access for a narrow reporting task has the blast radius of a compromised admin account, even if the compromise comes through a subtle prompt manipulation rather than a stolen password. Agents also need credentials (API keys, OAuth tokens, service-account secrets) and can be manipulated into revealing them, using them for an unintended purpose or passing them to a tool that should not have them. When several agents share a service account borrowed from another system, actions cannot be attributed to a specific agent and least privilege cannot be enforced. OWASP’s agentic list covers this as identity and privilege abuse.
Evidence status: Researcher demonstration. In May 2025, Invariant Labs showed that a malicious issue in a public repository could hijack an agent connected to the GitHub MCP server and lead it to copy data from the user’s private repositories into a public pull request. This was possible because the agent’s access token covered both. Invariant described it as an architectural issue at the agent-system level rather than a flaw in the server’s code. It was a demonstration, not a reported breach.
Mitigations. The controls are familiar from identity and access management, applied to a new type of principal:
Distinct identity — every agent has its own identity and a documented owner, not a shared service account.
Least privilege — only the permissions the task requires, nothing broader.
Scoped credentials — narrowly defined access tokens, such as one repository rather than every repository a user can reach.
Temporary access — permissions granted for the duration of a task and revoked afterward.
Task-specific authorization — permissions tied to a workflow rather than a general role.
Approval gates — human sign-off before high-impact actions execute.
4. Insecure MCP and Tool Integrations
Protocols such as the Model Context Protocol (MCP) connect agents to external tools, and that integration layer carries its own attack surface, separate from the model and from the tool itself. This is not a claim that MCP is inherently insecure. It means any layer connecting an agent to external systems needs the same scrutiny as any other integration point. The MCP specification’s own security best practices describe specific attack classes, including confused-deputy problems in MCP proxy servers and “token passthrough” (a server accepting tokens that were not issued to it and forwarding them downstream), which the specification forbids. Microsoft describes tool poisoning as a form of indirect prompt injection in which malicious instructions are placed in the description of an MCP tool.
Evidence status: Documented incident. In July 2025, AWS acknowledged that an unauthorized code change had been inserted into the open-source repository behind its Amazon Q Developer extension for Visual Studio Code, targeting how the extension’s command-line tooling executes commands. AWS Insider reports that AWS revoked and replaced credentials, removed the code and released a fixed version, and The Register reports AWS saying that no production services or end users were affected. Press reports describe the inserted text as a prompt telling the agent to delete files and cloud resources. The case shows how the code, configuration and prompts an agent loads can be a route to its tools.
What to evaluate before connecting an integration. Authentication: how the agent proves its identity to a tool server. Authorization: what it may do once authenticated. Provenance: whether the server or tool is what it claims to be. Third-party trust: whether the integration has been vetted. Input validation: whether data flowing in is checked. Output handling: whether data coming back is treated as untrusted by default.
Mitigations. Keep an approved list of servers and tools, and pin their versions. Review tool descriptions the way you would review code. Use tokens bound to the server they were issued for, and never pass client tokens through. Apply supply-chain controls to anything that supplies an agent with code, prompts or configuration; Microsoft recommends allowing only approved packages and applications.
5. Unexpected Code Execution
Agents that write or run code, scripts or shell commands can turn a manipulated instruction or a flawed plan into code running in a real environment. The risk grows when an agent runs with auto-approval, broad file-system access, or untrusted input. OWASP’s agentic list treats unexpected code execution as its own category.
Evidence status: Framework-identified risk. No specific incident is cited here.
Mitigations. Run agent-generated code in a sandbox with no standing credentials and restricted network access. Allow-list commands rather than trying to block-list dangerous ones. Keep production secrets out of the execution environment. Require approval before code runs outside the sandbox, and avoid auto-approval modes wherever an agent handles untrusted content.
6. Memory and Context Poisoning
Many agents keep memory across sessions to provide continuity: prior interactions, user preferences, task history. Memory poisoning occurs when false or malicious information is deliberately introduced into that memory and shapes the agent’s future behavior. Related problems include cross-session contamination, where information scoped to one context bleeds into another, and stale permissions or context, where an agent keeps acting on access that should have been revoked or on instructions meant for a single task, because nothing prompted it to refresh.
Evidence status: Framework-identified risk. OWASP’s agentic list covers this as memory and context poisoning.
Mitigations. Scope memory per user and per task. Validate what gets written, and do not let untrusted content write to persistent memory unreviewed. Expire or periodically review stored context. Make memory inspectable and purgeable. Refresh permissions rather than caching them.
7. Insecure Agent-to-Agent Communication and Orchestration
As enterprises deploy multiple agents that delegate to one another, trust boundaries multiply. If Agent A can direct Agent B, what verifies that the request is legitimate? What stops a manipulated agent from issuing instructions a downstream agent trusts implicitly? The orchestration layer, which decides which agent runs, which tools and context it receives, what credentials it uses and what it may execute, is a central control point. A flaw there can affect every agent it coordinates.
Risks worth evaluating include authorization errors in how the orchestrator grants access, insecure routing to the wrong agent or tool, agent impersonation, tool substitution, context leakage between sessions, cross-agent privilege escalation through a poorly isolated path, and unsafe delegation beyond an agent’s intended scope.
Evidence status: Framework-identified risk. OWASP’s agentic list covers insecure inter-agent communication.
Mitigations. Give each agent a unique, verifiable identity. Define what one agent may ask another to do. Verify message integrity so requests cannot be tampered with in transit. Isolate context between agents and sessions. Treat the orchestrator like an identity provider or other central infrastructure, with access reviews, logging and testing.
8. Cascading Failures and Unintended Autonomous Behavior
An agent can satisfy its instruction literally and still cause harm. This is not because it has “gone rogue” but because an ambiguous objective, excessive autonomy and inadequate guardrails leave room for unintended interpretations. An agent told to “resolve the customer’s issue as quickly as possible” might take a shortcut that violates a policy nobody encoded (an illustrative scenario). In connected workflows, one agent’s error can feed the next, so a small failure spreads before anyone notices. OWASP treats cascading failures and rogue agents as separate categories; they are grouped here because the controls overlap.
Evidence status: Framework-identified risk.
Mitigations. Write clearer objectives and constrain the action space. Add review points for consequential decisions. Use rate limits and circuit breakers so one failure cannot run unchecked. Keep a tested way to stop an agent (a kill switch). Monitor behavior against a baseline so drift is visible.
9. Human–Agent Trust Exploitation
Human oversight is one of the controls this guide recommends, and it has its own failure mode. Agents produce fluent, confident output, and people tend to approve what looks reasonable, especially when approvals are frequent. A manipulated agent can present a harmful action convincingly, and an analyst can accept an agent’s conclusion without checking it. OWASP’s agentic list names human–agent trust exploitation as a category.
Evidence status: Framework-identified risk.
Mitigations. Show approvers the actual action and data involved, not only the agent’s summary of it. Reserve approvals for high-impact actions so they stay meaningful rather than routine. Require independent verification of consequential findings. Train staff on how agent-assisted social engineering works.
10. Sensitive Data Exposure and Exfiltration
A compromised or manipulated agent with enough access can send sensitive data outside the organization: PII, credentials, financial records, source code, customer information or confidential documents. This is less a separate vulnerability than the outcome of the risks above. EchoLeak and the GitHub MCP demonstration were both exfiltration chains. But it is the outcome most enterprises care about most, and the point where agent security and data security overlap directly. An agent with narrow, task-scoped access has a far smaller exfiltration surface than one with broad standing access “just in case.” MITRE ATT&CK catalogues data exfiltration as a tactic in its own right.
Evidence status: Documented incident and researcher demonstration (see risks 1 and 3).
Mitigations. Data minimization, egress controls, output inspection and controlled logging, covered under “Protecting Sensitive Data From AI Agents” below.
Not on the list: conventional vulnerabilities. Agents also inherit the weaknesses of the libraries, containers, databases, cloud services and operating systems they run on. An agent built on outdated dependencies or connected to an unpatched database carries all the conventional risk that existed before AI, plus the agent-specific risks above. Agent security is additive to standard application and infrastructure security, not a replacement for it.