Published on
Teams are shipping Large Language Model (LLM) features faster than their secure development programs can keep up with. That's why the Open Worldwide Application Security Project (OWASP) has created a dedicated Top 10 list to address it.
The OWASP Top 10 for LLM applications ranks the ten security risks most likely to matter in software built on large language models. The 2026 release kept all ten risk areas from 2025 but reordered them, as it now uses incident data in addition to votes to create its ranking.
Why Does the OWASP LLM Top 10 Matter for Developers Building AI Features?
The 2026 list is the first version OWASP checked against a record of what has actually gone wrong. While earlier editions ranked risk by practitioner vote alone, this one combines that vote with 7,714 incidents pulled from public vulnerability databases and an AI-harm database.1
The vote now carries three-quarters of the weight while incident data accounts for the remaining quarter. That's enough to move an entry when the belief and the evidence disagree.
Practitioners voted prompt injection as the number one risk, though OWASP's incident report ranks it outside the top ten entirely. OWASP says that's because teams already defend against injection aggressively, so fewer attempts succeed and fewer still end up documented as public incidents. That's why prompt injection is still number one on the final list.
Misinformation goes the other way. Voters placed it near the bottom while the incident record placed it near the top, which shows just how much practitioners were underweighting it. It ended up placing seventh on the final list.
That is one of the biggest benefits of including real incident data in the rankings. The practitioners who voted on this list put misinformation near the bottom, but the record of what has gone wrong moved it up two places.
What Happens When LLM Security Risks Go Unaddressed?
Attackers have used unaddressed LLM risks to pull authentication codes out of corporate assistants and quietly move company data out through a chatbot.
Johann Rehberger showed one version against Microsoft 365 Copilot in August 2024. An attacker sent the victim a phishing email carrying a Word document with hidden instructions that told Copilot to adopt a new persona once it read the file. Copilot then searched the victim's mailbox for Slack multi-factor codes, hid what it found inside invisible Unicode characters, and displayed the result as a normal-looking link. Clicking that link sent the codes to the attacker.2
Check Point disclosed a case in March 2026 that required no confirmation from the victim. A single malicious prompt, disguised as a helpful oneopened a DNS-based channel out of ChatGPT's isolated code-execution environment, which gave the attacker a way to pull data out without anyone noticing. Check Point's medical proof of concept showed ChatGPT assuring the user that no data was leaving, while it was secretly sharing the patient's name and its own assessment with the attacker.3 Open AI fixed the issue in February 2026.
What Are the OWASP Top 10 Risks for LLM Applications?
Prompt injection and sensitive information disclosure are the top two risks for LLM applications according to the 2026 OWASP list. Excessive agency jumped to third place, unbounded consumption rose four places, and improper output handling fell to tenth place. System prompt leakage also has a new name: hidden context exposure.
LLM01: What Is Prompt Injection, and How Do You Guard Against It?
Prompt injection is the technique an attacker uses to change a model's behavior by placing instructions in the text the LLM reads. A model processes instructions and data as one stream of tokens, so it cannot separate your system prompt from a sentence buried in a retrieved document.
An attacker can write that sentence into a support ticket, a web page, a tool response, or last week's memory entry, since the model will eventually read all of them. The 2026 entry also includes images and audio.1
OWASP says that no reliable prevention exists today, so you must protect everything the model has access to and assume the model itself will be compromised. Keep credentials and the power to write, send, or delete within your application code. Route every privileged call through a policy engine that checks what the model asked for and which arguments it supplied before it executes anything.
LLM02: How Does Sensitive Information Disclosure Happen in LLM Applications?
An LLM application can leak sensitive data through its logs, telemetry, tool calls, and stored embeddings. That's much more than what the model tells the user. Measurable properties like response timing and token length can disclose information too, even if not immediately evident.
Many of those leaks start with what the team connected the model to. A shared drive with old permissions or an unscoped knowledge base could give the model access to documents a given employee has no right to open. When that employee asks the model a question, it will retrieve those documents and share their contents in its answer.
The way to prevent this is by enforcing authorization inside the index query itself, at the document and chunk level. Filtering after an answer has already been generated cannot undo a chunk the model has already read.
LLM03: What Is Excessive Agency, and Why Is It Riskier in Agentic Systems?
Excessive agency is what lets a model's bad output turn into a harmful act. The model hallucinates or an attacker injects instructions, and then the model calls a tool that can delete company records or forward sensitive emails to an outside address.
This is riskiest when a team gives an agent tools it doesn't need. For example, they could connect a read-only lookup to the database with an identity that can also delete rows, or skip the approval step before the agent takes an action that cannot be reversed.
You can minimize your exposure by enforcing authorization in your code, where the rules are deterministic and auditable. Route tool calls through a policy decision point that validates each request against those rules, auto-approving reversible actions and sending irreversible ones to a human.
LLM04: What Supply Chain Risks Come With Third-Party Models and Plugins?
Attackers target the models, adapters, datasets, and conversion pipelines you pull from public hubs. A reviewer reading source code can spot malicious functions, but a backdoor in model weights can stay dormant until a specific input wakes it up.
Coding assistants then created a second path when they started inventing package names that don't exist. Attackers register those invented names on public registries before anyone does, so a developer who installs the package the model recommended is installing code the attacker wrote.
Pin artifacts to immutable digests and check signatures against a transparency log to prevent this. Apply the same scrutiny to conversion and merge services, where an artifact can change after you've approved it.
LLM05: How Can Training Data and Model Poisoning Compromise an LLM Application?
Poisoning corrupts what a model learned, so the damage persists even after you patch everything else. An attacker could contribute tainted data to a public dataset, a fine-tuning set, or a RAG corpus, and the model will learn to obey the attacker.
Attackers need very little data to do this. Researchers compromised models between 600 million and 13 billion parameters using as few as 250 poisoned documents.1 The size of the training set made no difference, so a larger corpus doesn't give you more protection.
What can protect you is tracking lineage for every dataset and artifact, validating what you ingest, and probing for triggers after each alignment cycle. This should be an ongoing process, as you never know which models have dormant backdoors.
LLM06: What Is Unbounded Consumption, and How Does It Lead to Cost or Denial-of-Service Risk?
Unbounded consumption is what an attacker exploits when nothing in your application caps how much compute a single request can spend. The economics favor them, since a short prompt costs almost nothing to send and can keep the model working for minutes while you pay for every token it produces.
An attacker can write a brief, ordinary-looking prompt that pushes a reasoning model into a long loop, burning tokens while passing every input-size check you have. Agents make this worse, since one request can fan out into hundreds of tool calls before anyone can stop it.
You can no longer protect the system by limiting how many requests arrive per second. Instead, enforce limits on tokens per minute and estimated cost per request, set spending caps that stop inference when they're hit, and give every agent a step limit and a recursion depth limit.
LLM07: How Does an LLM Application Contribute to Misinformation Risk?
An LLM application produces misinformation when the model generates something false that reads as credible. Readers trust a confident, well-structured answer more than they should, as the model sounds just as sure about its answer whether it's right or wrong.
Agents raise the stakes, as a model might infer that a customer's refund was authorized when it wasn't and trigger the payout. The agent downstream would then treat that decision as fact and keep going.
You can reduce this risk by separating generation from execution. Require outputs to be grounded in current, authoritative sources and verify the claim before anything acts on it.
LLM08: How Does Hidden Context Exposure Expose an Application’s Logic?
Hidden context exposure happens when an attacker extracts the system prompt and the other instructions your application loads into the model before users start sending prompts. That gives them your application's logic. For example, an attacker who reads your refusal rules learns which phrasings trigger a refusal and can work around them. If you stored credentials in there, attackers can also access them.
That's why it's so important to design on the assumption that an attacker will read your hidden context. Keep credentials and connection strings out of it entirely just in case. Enforce authorization and content policy in deterministic code where an attacker cannot talk their way past the rules.
LLM09: What Are Vector and Embedding Weaknesses in RAG-Based Applications?
Vector and embedding weaknesses let an attacker manipulate which documents your application retrieves, without ever writing a malicious instruction. Your pipeline stores documents as vectors and returns the ones closest to the user's query, which is why an attacker can write a document engineered to land close to a query they want to hijack, then wait for your application to retrieve it as trusted context.
Always restrict your searches to the information the requester is allowed to see when your application searches the index. Applications that search everything and filter the results afterward can leak information through result counts and response times.
LLM10: Why Does Improper Output Handling Create Downstream Vulnerabilities?
Improper output handling is when your application passes model output into another system without checking it first. An attacker who lands a prompt injection can decide what the model says next. Your application would take that text and pass it to a shell, which executes it as a command, or into a database query to execute it as SQL.
Interfaces have the same problem. A terminal obeys control characters by design, so model output could move the cursor and overwrite text a developer already read on screen. A chat interface that auto-renders Markdown images would then fetch whatever URL the model supplies, sending conversation data to whoever controls that address.
You can stop the execution problem by encoding model output for every context it enters, whether that's HTML, SQL, or a terminal. The exfiltration needs its own control, so disable auto-fetching of external resources wherever you render what the model produced.
Why Did OWASP Create a Separate List for LLM Applications?
OWASP created a separate list because problems like prompt injection and training data poisoning have no direct equivalent in the Web Application Top 10. Parameterized queries work well because a database can tell a command from a value. A model cannot make that distinction at all, so there is nothing to parameterize.
The 2026 release also separates LLM applications from agentic ones by who makes the decisions. This list applies when your code calls the model and then decides what to do with the answer. When the model chooses which tool to call and acts on its own result, OWASP covers that under its Top 10 for Agentic Applications.4 Plenty of real systems do both, which is why it's important to read both lists.
How Can Developers Mitigate These LLM Security Risks in Practice?
Start from the assumption that someone will get instructions past your model, then limit what an attacker can do once that happens. OWASP leads with this in its preface, telling teams to stop trying to build a model nobody can fool and instead build the systems around it so nothing breaks when the model is fooled.1
Incorporate these concrete practices:
- The lethal trifecta check: An agent that can read private data, take in untrustworthy content, and talk to the outside world has the three conditions for serious exploitation. You can break the chain by cutting off any one of them, since an attacker who cannot send data outside your system has no way to profit from reading it.
- Red teaming with your defenses disclosed: A defense tested against known attacks will look solid, though you never know what someone could invent after reading your defense design. Researchers gave attackers the design of a dozen recent defenses and let them write new attacks against each one. More than 90% of those attacks succeeded.1
- Monitoring that assumes compromise: Record every tool call your agents make, including the arguments. You can then catch an agent reading from a database it has no business in, or sending an email to an outside address, while the attack is still running.
What Security Controls Apply Across Multiple LLM Risks?
You can address several entries on the list with the same few controls:
- Authorize outside the model: Your code decides what each request is allowed to do, so an agent cannot act beyond its scope and your application cannot hand back documents the person asking has no right to see.
- Validate at every boundary: Treat everything that enters the model as untrusted input and what leaves it as untrusted output. This covers prompt injection and improper output handling.
- Verify everything you load: Sign your artifacts, pin digests, and track dataset lineage to catch both supply chain tampering and poisoning.
- Cap what one request can consume: Set token limits, spending ceilings, and step limits on agents to stop unbounded consumption and runaway tool loops.
How Does the OWASP LLM Top 10 Fit Into Existing AppSec and Compliance Programs?
You can add the LLM Top 10 to your existing secure development work without replacing any of it. If your team already works in MITRE ATLAS, MITRE ATT&CK, CWE, NIST AI 600-1, or the CSA AI Controls Matrix, OWASP connects all ten risks to those frameworks.
OWASP doesn't make deliberate connections to SOC 2 and ISO 27001 programs, though the overlap is obvious once you look. An LLM application that leaks customer records would fail the confidentiality criteria you already report on. The bottom line is that your auditor will want proof that you identified the risk and acted on it.
How Does This List Connect to the Original OWASP Top 10 for Web Applications?
Every risk in the web application Top 10 still applies to your LLM application. Authentication, access control, and injection problems do not go away just because a model now handles part of the request. The LLM list covers only the new risks a model introduces.
OWASP puts LLM10 Improper Output Handling in the same CWE categories as cross-site scripting. Your team likely already has years of experience defending against those weaknesses. Your model is simply a new source of the same untrusted input, so the encoding discipline you already practice is the defense.
How Can Organizations Build OWASP LLM Top 10 Awareness Into Developer Training?
The best way for developers to learn these risks is by exploiting them. Give a developer a running application, let them write a prompt injection that works, and have them close the hole themselves. They'll then know how to identify the same weakness in their own code months later.
Security Journey builds this into role-based training, with hands-on labs and capture-the-flag exercises drawn from real LLM attack patterns, including coursework on the OWASP Top 10 for LLM Applications. Developers practice on working applications where getting it wrong costs nothing and teaches them something.
References
- OWASP GenAI Security Project. “OWASP GenAI LLM Top 10 2026.” August 2026. https://genai.owasp.org/resource/owasp-genai-llm-top-10-2026/
- Rehberger, Johann. “M365 Copilot Prompt Injection, Tool Invocation and Data Exfil Using ASCII Smuggling.” Embrace The Red. August 2024. https://embracethered.com/blog/posts/2024/m365-copilot-prompt-injection-tool-invocation-and-data-exfil-using-ascii-smuggling/
- Check Point Research. “ChatGPT Data Leakage via a Hidden Outbound Channel in the Code Execution Runtime.” March 2026. https://research.checkpoint.com/2026/chatgpt-data-leakage-via-a-hidden-outbound-channel-in-the-code-execution-runtime/
- OWASP GenAI Security Project. “OWASP Top 10 for Agentic Applications for 2026.” December 2025. https://genai.owasp.org/resource/owasp-top-10-for-agentic-applications-for-2026/