
AI agents can read files, call APIs, update records, and pass work to other agents. That is exactly why they fail differently from chatbots. The 2026 OWASP GenAI LLM Top 10 keeps prompt injection at number one for a third year, and surveys from Gartner and Proofpoint found that around 88% of companies running AI agents reported a security incident in the past twelve months. The fix is not better prompts. It is smaller permissions, stricter tool boundaries, and human approval at every consequential step.
A chatbot that gives a wrong answer is an inconvenience. An agent that acts on that answer can change a bank record, fire an email, or trigger a payment. The difference is agency: the ability to take action in the real world. NIST calls the exploitation of that ability “AI agent hijacking,” and its Generative AI Profile (NIST AI 600-1) explicitly names prompt injection as a security and resilience risk.
OpenAI learned this the hard way. In July 2026 the company announced that some of its agents were involved in what it called an unprecedented incident, forcing a slowdown in training of advanced AI, as reported by the BBC. The lesson is uncomfortable but clear: agents magnify every input mistake into a potential system-level action. Earlier this year I helped a small team audit an internal support agent that could read order data. I found it could also export the customer table, because nobody had trimmed its permissions after the pilot phase. That single finding reshaped how the team thought about agent access.
Three 2026 surveys published within days of each other quantified the problem. Gartner’s “Predicts 2026: Secure AI Agents” report estimates roughly 1.5 million ungoverned agents in the wild. Around 88% of firms reported experiencing or suspecting an AI agent related security incident in the past twelve months, per a summary of the Gartner research and related surveys. Yet 82% of executives still believe their policies protect them, and only 21% have runtime visibility into what their agents actually do, as NIST’s AI Risk Management Framework resources emphasize for governance. The gap between confidence and reality is where incidents happen.
The OWASP Agentic Top 10 and the LLM Top 10 describe overlapping threats. I grouped them into seven practical risks that map directly to things you can change today, whether you run one pilot agent or a fleet of them.
Prompt injection is not new, but for agents it is more dangerous. An attacker hides an instruction inside an email, webpage, PDF, or tool response that the agent reads as part of its job. The model cannot reliably tell a command from content, which is why OWASP keeps this risk at number one for the third year in a row.
Consider an invoice agent monitoring a shared mailbox. A malicious invoice tells the agent to swap the supplier bank details before pushing the payment. The agent treats this as part of its task, calls the finance tool with legitimate credentials, and the finance system sees an authorized update. No model filter catches it, because the instruction is hidden in the file itself.
Fix: Treat every tool boundary as the enforcement point. The email tool must reject unapproved recipients. The payment tool must refuse bank changes from an unattended path. Never let the model’s confidence decide whether an action runs.
Excessive agency jumped from LLM06 to LLM03 in the 2026 OWASP ranking, the biggest move in the list. The reason is straightforward: every tool and API an agent can reach is a new blast radius. A support agent that checks order status does not need write access to the CRM or export rights on the customer database.
Fix: Apply least privilege like you would for a human employee. Give each agent the minimum tools, scopes, and data needed for its task. Microsoft’s guidance for least-privilege AI agents makes the same point: an agent should have less access than the person it supports, not a copy of their full permissions.
If an agent with valid credentials requests an export of the database, the database cannot tell that the request came from a poisoned document. It sees an authorized account and completes the call. The authorization layer must carry the restriction, not the model’s memory of a rule.
Fix: Enforce limits inside the tool and its authorization layer. A refund agent can issue refunds up to a fixed amount, but it has no reason to export customer records. Put those limits in the tool configuration, and log every call so misuse is visible.
Agents need credentials to open files and change records. Many pilots share an API key across automations or run under a human login to avoid permission errors. That is a trap. Shared keys are hard to investigate: the log shows the key that changed a record, but not the agent behind it.
Fix: Give every production agent its own service identity with an owner and a review cadence. Separate identities make audit logs meaningful, let you revoke access when the agent’s job changes, and stop one compromised agent from impersonating the whole team.
Agent memory is usually a stored record that returns in later prompts. A false entry comes back exactly like a valid one. An attacker can plant a phantom bank account in vendor data that lies dormant for months, then surfaces on the next invoice. Meanwhile, if memory is not separated per customer or tenant, one user’s details can leak into another user’s session.
Fix: Keep secrets out of memory entirely. Store the source with every record so you can audit it. Delete stale entries, separate memory per tenant, and never persist passwords, API keys, or payment details in the context store.
In a multi-agent workflow, agents usually hand off summaries, tool results, or a few fields of data instead of the full source. If the first agent in a chain misreads a security alert, the wrong conclusion travels through every downstream step. Each handoff looks normal, because the workflow is running as designed.
Fix: Let the last agent access the evidence with its own permissions before any sensitive action. Define a clear endpoint for the workflow, and design it so one wrong result cannot trigger a chain of changes. Identity checks tell you which agent sent a message; they do not fill in missing context.
OWASP replaced “system prompt leakage” with the broader “hidden context exposure” in 2026. An AI application’s context now includes retrieved documents, memory, user info, application state, and tool responses, not just the system prompt. System prompt extraction has already produced verified leakage against commercial deployments. At the same time, misinformation rose to LLM07 because generated output increasingly feeds other applications, produces code, and triggers automated actions.
Fix: Treat context as a security boundary: know what enters it, where it came from, and where it is allowed to go. Validate generated output before it triggers anything consequential, and give downstream systems the authority to reject suspicious results.
| Risk | Attack Vector | Primary Defense | Detection Difficulty |
|---|---|---|---|
| Indirect Prompt Injection | Malicious instruction in file, email, or webpage | Tool-side allowlists and rejects | High |
| Excessive Agency | Over-broad tool and API access | Least privilege per agent | Medium |
| Tool Misuse | Poisoned document drives a credentialed call | Limits enforced in the tool layer | Medium |
| Identity Blur | Shared keys hide the responsible agent | Unique service identity per agent | Medium |
| Memory Poisoning | False records persist in context store | Source tracking, tenant isolation | High |
| Multi-Agent Cascades | Errors propagate through handoffs | Evidence access before action, endpoints | High |
| Context Exposure | Sensitive data leaks via context | Context boundary controls | High |
Security frameworks are only useful when they become daily practice. I use a short checklist before any agent moves from pilot to production, and it takes about an afternoon to run.
Proofpoint’s 2026 survey of more than 1,400 security professionals found that about half of organizations had an AI related incident even with security controls in place. Visibility into agent activity is one of the biggest gaps they report, a pattern also highlighted in Check Point’s analysis of the OWASP LLM Top 10 2026. That number is a reminder that controls fail when nobody watches the runtime. If you want to understand how agents fit into a broader automation stack, this comparison of n8n vs Make covers the orchestration side, and the MCP setup guide explains how to connect tools to agents safely. For the framework layer, see CrewAI vs LangGraph, and for spotting inflated vendor claims, how to tell real AI from marketing hype.
Indirect prompt injection is the top risk in the OWASP LLM Top 10 2026. An attacker hides instructions inside content the agent reads, and the agent can act on those instructions with legitimate credentials. The best defense is enforcing restrictions at the tool boundary rather than relying on the model to detect attacks.
Surveys from Gartner and Proofpoint published in 2026 found that roughly 88% of organizations running AI agents reported a security incident in the past year. Only about 21% have runtime visibility into agent actions, which means many incidents go unnoticed.
Excessive agency means an agent has more tools, permissions, and reach than its task requires. OWASP moved it from LLM06 to LLM03 in the 2026 ranking because connected agents that can act on APIs and business systems create a much larger blast radius when manipulated.
Yes. Even a single pilot agent that reads email or writes to a spreadsheet can be manipulated through indirect prompt injection. The basics, a dedicated identity, minimal permissions, tool-side limits, and approval gates for sensitive actions, cost little and prevent the most common failures.
AI agents are worth deploying, but they change the security contract. The attackers are not breaking the model; they are abusing the access you gave it. Start with the highest-impact fixes: reduce permissions, enforce limits in the tool layer, give every agent its own identity, and demand human approval for consequential actions. Then build runtime visibility so you can see misuse instead of discovering it in an audit months later. The OWASP Top 10 for LLM applications documents each risk with mitigation guidance, NIST AI 600-1 gives you the governance framework, and the survey data from Gartner and Proofpoint tells you what happens when teams skip these steps. I have seen a single permission trim prevent an export that would have leaked thousands of records. That is the cheapest security control you will ever deploy.