OWASP Top 10 for LLM Applications
As large language models move from demos into production systems, they bring a new class of security risks that don't map cleanly onto traditional web application vulnerabilities. The OWASP Top 10 for LLM Applications catalogs the most critical of these risks, giving developers, security engineers, and AI teams a shared vocabulary for identifying and mitigating them.
Why LLMs Need Their Own Top 10
The classic OWASP Top 10 focuses on how untrusted input breaks deterministic code: injection, broken access control, misconfiguration. LLM applications introduce a fundamentally different attack surface, natural language itself becomes an input channel that can steer model behavior, and the model's output is often trusted and acted on downstream. That shift is why OWASP maintains a separate, dedicated list for LLM-specific risks.
The OWASP Top 10 for LLM Applications
1. Prompt Injection occurs when crafted input, direct from a user or indirect via a document, webpage, or tool result, manipulates the model into ignoring its instructions or taking unintended actions. Because there's no hard boundary between "instructions" and "data" in a prompt, this is one of the hardest LLM risks to fully eliminate. Mitigation relies on treating all model output as untrusted, enforcing least privilege on any tool the model can call, and adding human approval for sensitive actions.
2. Sensitive Information Disclosure happens when a model reveals confidential data, whether personal information, proprietary business logic, or secrets, memorized during training or included in its context window. This can leak through direct queries, cleverly chained prompts, or overly permissive retrieval-augmented generation (RAG) pipelines. Data minimization, output filtering, and strict access controls on what the model can retrieve are the key defenses.
3. Supply Chain risks cover the entire pipeline behind an LLM application: pretrained models, fine-tuning datasets, plugins, and third-party libraries. A poisoned base model, a compromised dependency, or an untrusted community fine-tune can undermine the security of everything built on top of it. Vetting model provenance, pinning dependencies, and maintaining a software bill of materials (SBOM) help manage this exposure.
4. Data and Model Poisoning refers to the deliberate manipulation of training, fine-tuning, or embedding data to introduce backdoors, biases, or degraded performance. Because poisoned behavior can lie dormant until a specific trigger appears, it's difficult to detect through normal testing. Validating data sources, sandboxing training pipelines, and monitoring for anomalous outputs reduce this risk.
5. Improper Output Handling arises when an application passes LLM-generated content downstream, into a shell, a database query, a browser, or another system, without validation or sanitization, effectively trusting the model's output as safe code or markup. This can lead to classic vulnerabilities like XSS, SSRF, or remote code execution, just triggered through the model instead of a form field. The fix is familiar: treat LLM output exactly like any other untrusted user input.
6. Excessive Agency describes LLM-based systems granted more permissions, tools, or autonomy than a given task requires, so a manipulated or simply mistaken model action causes outsized damage. This risk grows directly with how much an application lets a model do on its own. Limiting tool permissions to the minimum needed, requiring confirmation for high-impact actions, and logging every action a model takes keep the blast radius small.
7. System Prompt Leakage occurs when the hidden instructions that shape a model's behavior are extracted by an attacker, exposing internal logic, business rules, or, worse, secrets that were mistakenly embedded in the prompt itself. Leaked system prompts also make other attacks, like prompt injection, easier to craft. System prompts should never contain secrets, and applications shouldn't rely on prompt secrecy as a security control.
8. Vector and Embedding Weaknesses affect retrieval-augmented generation (RAG) systems, where poorly secured vector databases or embedding pipelines let attackers inject malicious content into the knowledge base or extract sensitive embedded data. Since the model treats retrieved content as trusted context, a compromised vector store can quietly poison every downstream response. Access control on embedding pipelines and validation of ingested content are essential safeguards.
9. Misinformation covers the tendency of LLMs to produce confident, plausible-sounding but factually incorrect output, commonly called hallucination, which becomes a security issue when that output drives decisions, code, or published content without verification. This is especially dangerous in domains like security, legal, or medical advice. Grounding responses in verified sources, citing evidence, and keeping a human in the loop for high-stakes decisions all help.
10. Unbounded Consumption happens when an application doesn't limit how much a model can be asked to compute, through long inputs, recursive agent loops, or high-volume requests, leading to denial of service or runaway infrastructure costs. Rate limiting, input/output size caps, and timeouts on agentic loops keep resource usage predictable.
Why This Matters for Security Engineers
Most of these risks can't be patched away the way a traditional vulnerability can; they're inherent to how LLMs process language and take action. That makes secure design, least privilege, and defense in depth even more important than in conventional application security. Treating an LLM as a powerful but fundamentally untrusted component, rather than a trusted piece of business logic, is the mental model that holds up best across all ten risks.
Conclusion
The OWASP Top 10 for LLM Applications is a fast-moving list, reflecting how quickly the field itself is evolving. Whether you're building AI features into an existing product or securing someone else's, understanding these risks is becoming as fundamental to application security as the original OWASP Top 10.