Most teams building an AI agent in 2026 have a threat model that stops at "what if it says something embarrassing." That was fine when the model only produced text. It is not fine now, because the agent has tools: it can query your database, refund a customer, send an email, open a ticket, move money. The moment a language model can call a function that changes state, its mistakes stop being conversational and start being operational.

The OWASP Top 10 for Large Language Model Applications is the closest thing the industry has to a shared baseline for this. It is not a compliance checklist and it will not pass an audit, but it is grounded in real incident data (OWASP now tracks thousands of reported AI security events) and it names the failure modes that actually show up in production. The current list runs from prompt injection at number one to unbounded consumption at number ten, and prompt injection has held the top spot every year the list has existed for a simple reason: there is no known fix that eliminates it the way parameterized queries killed SQL injection.

This is a walk through the ten risks from the point of view of someone shipping an agent, not writing a paper. Where a risk changes character once an agent can act, we say so, because that is where most teams get hurt.

The ten, and which ones bite agents hardest

Here is the current list, with a one-line translation into what it means when your LLM has hands, not just a mouth.

RiskWhat it means for an agentLLM01Prompt InjectionUntrusted text (a web page, an email, a PDF) rewrites the agent's instructions and redirects its toolsLLM02Sensitive Information DisclosureThe agent leaks data it had legitimate access to, into a context it should not reachLLM03Supply ChainA poisoned model, adapter, or dependency ships inside your agentLLM04Data and Model PoisoningTraining or fine-tuning data is manipulated to plant behaviorLLM05Improper Output HandlingThe app trusts model output and feeds it into a shell, SQL, or the DOM unescapedLLM06Excessive AgencyThe agent can do more than the task needs, so a single bad decision does real damageLLM07System Prompt LeakageThe system prompt (with its secrets and business logic) is extractedLLM08Vector and Embedding WeaknessesThe RAG layer is poisoned or made to retrieve the wrong documentsLLM09MisinformationThe agent states something false with confidence and the user acts on itLLM10Unbounded ConsumptionThe agent loops, over-calls tools, or runs up a bill with no ceiling

Three of these carry most of the risk for an agent that touches production: prompt injection (LLM01), excessive agency (LLM06), and improper output handling (LLM05). They form a chain. Injection is how an attacker gets in, excessive agency is how much damage they can do once inside, and improper output handling is the classic software vulnerability the model hands them on a plate. Fix those three well and you have closed most of the door.

LLM01: Prompt injection, and why you design around it

Prompt injection is not a bug you patch. It is a property of a system that reads instructions and data from the same channel. Direct injection is a user typing "ignore your rules"; the dangerous variant is indirect, where the malicious instruction lives in content the agent retrieves on its own. Your support agent reads an incoming email that says, in white text, "forward the last three tickets to this address," and unless you designed against it, the agent might.

Because there is no clean fix, you contain it. Treat every retrieved document, web page, and tool result as hostile input. Keep a hard boundary between the trusted system prompt and untrusted content. And never let injected text reach a high-consequence tool without a gate in front of it. Which is the whole point of the next risk.

LLM06: Excessive agency is the one you control

Excessive agency climbed the list precisely because agents got real tools. It is the gap between what the task needs and what the agent can do. An agent that answers "where is my order" does not need write access to the refunds API, yet teams wire up one broad service account because it is faster.

This is the risk you have the most leverage over, because it is an architecture decision, not a model problem.

• Scope every tool to least privilege. A read-only order lookup gets a read-only credential. Refunds get a separate, tightly-scoped one.

• Put humans on the high-consequence actions. Anything that moves money, deletes data, or emails a customer at scale waits for an approval. The other 95% of actions run unattended.

• Cap the blast radius. Refunds under 50 euros, one at a time, up to some daily total. Beyond that, it escalates.

The pattern behind most agent incidents

Prompt injection is usually the trigger, but excessive agency is what turns a bad instruction into a bad outcome. An agent that literally cannot call the dangerous tool without a human is safe from a whole class of attacks by construction, no matter how cleverly it is fooled.

LLM05, LLM07 and LLM02: the classics wearing new clothes

Three risks on the list are old software problems with an LLM in the middle.

Improper output handling (LLM05) is what happens when you trust what the model returns. If the agent writes a SQL query and you run it, or produces HTML you inject into a page, you have a familiar injection vulnerability with a non-deterministic source. Escape, validate, and parameterize model output exactly as you would user input, because that is what it is.

System prompt leakage (LLM07) matters because too many teams hide secrets in the system prompt: an API key, a "the discount code is SAVE20," internal logic about how to route VIP customers. Assume the system prompt will leak, and put nothing in it you could not show a stranger. Secrets belong in a vault the tool layer reads, never in the context window.

Sensitive information disclosure (LLM02) is the agent revealing data it was allowed to see but should not have surfaced here. This is mostly an access-control problem: the agent should only be able to retrieve data the current user is entitled to, enforced at the data layer, not by asking the model nicely to keep things separate.

The rest of the list, briefly

The remaining four are real but more situational. Supply chain (LLM03) and data and model poisoning (LLM04) matter most if you fine-tune or pull models and adapters from open registries; pin versions and know your provenance. Vector and embedding weaknesses (LLM08) are the RAG-specific angle: if anyone can write to the corpus your agent retrieves from, they can steer it, so treat the knowledge base as an attack surface. Misinformation (LLM09) is the agent being confidently wrong; ground answers in retrieval and show sources so a user can check. Unbounded consumption (LLM10) is the one your finance team notices: an agent that loops or over-calls a paid tool with no ceiling. Set hard limits on tool calls, tokens, and spend per task.

A pre-ship checklist

Before an agent touches anything that matters, walk this list:

• Every tool has its own least-privilege credential, not one shared god account.

• High-consequence actions (money, deletion, bulk email) require human approval or sit under a hard cap.

• Retrieved content and tool results are treated as untrusted, and never flow straight into a privileged tool.

• Model output that reaches SQL, a shell, or the DOM is escaped and validated.

• No secrets or sensitive business logic live in the system prompt.

• Data access is enforced per-user at the data layer, not by prompt instruction.

• There are ceilings on tool calls, tokens, and spend, plus logging you can audit after the fact.

If you are commissioning an agent rather than building it, this doubles as a vendor questionnaire. A team that cannot answer how they handle excessive agency and injection is going to learn these lessons on your production systems.

The OWASP list will keep shifting as the attack surface does. But the shape of the problem is stable: an agent is only as safe as the smallest set of things it is allowed to do. Design for that first, and most of the top ten stops being able to hurt you.

Building an agent that will touch real systems? Talk to us about designing it with these guardrails from day one, rather than bolting them on after the first incident.