OWASP LLM Top 10The 2026 List, Explained
Insurance applications and customer questionnaires now ask a pointed question about AI: how do you handle the ten weaknesses on the industry's standard list for language-model software? The August 2026 edition reshuffled that list and renamed one entry while widening several others. Below we explain each risk in plain English and show what moved since 2025. For every entry you get the safeguards and tests Petronella Technology Group, Inc. uses in real engagements.
What Is the OWASP LLM Top 10?
The OWASP LLM Top 10 is the OWASP GenAI Security Project's community-ranked list of the ten most critical security risks in applications built on large language models. Its formal name is the OWASP Top 10 for LLM Applications, and the current edition is the 2026 list (v1.0), published in August 2026. Each entry names a class of weakness and describes how it is exploited. It then recommends prevention and mitigation strategies.
Key Takeaways
- The current edition is 2026. The 2026 OWASP Top 10 for LLM Applications (v1.0) replaces the 2025 list. If a vendor questionnaire or internal standard still cites 2025 numbering, the IDs no longer line up.
- The top three are Prompt Injection, Sensitive Information Disclosure, and Excessive Agency. The first two held their positions. Excessive Agency climbed from sixth to third.
- Nothing was added or removed. The 2026 changes are reordering, one rename (System Prompt Leakage became Hidden Context Exposure), and scope expansions inside existing entries.
- Unbounded Consumption rose four places and Improper Output Handling fell furthest, from fifth to tenth, although its scope grew to include insecure code produced by AI coding assistants.
- The list covers the model as a component. Once a model acts on its own with tools and memory, OWASP directs readers to its separate Top 10 for Agentic Applications.
- Use it as a threat model and a test plan, not a checkbox. Map each entry to your real AI deployments, fix the top three first, and verify the controls by attacking them.
OWASP built the list for the people who design and secure software, but it has become shared vocabulary well beyond engineering. Cyber insurance applications ask about it. So do customer security questionnaires and audit requests, which now ask how an organization addresses "the OWASP LLM Top 10" in the same way they once began asking about the original OWASP Top 10 for web applications. The 2026 edition also maps its entries to NIST AI RMF and NIST AI 600-1, MITRE ATLAS, and CWE, which makes it easier to connect LLM findings to frameworks you may already report against. An earlier edition of the list dates back to 2023, and the project has revised it as the technology and the evidence changed.
You can read the source material on the OWASP GenAI Security Project site and download the full 2026 document. What follows is our working interpretation of it: what each risk means for a small or mid-size organization that uses a vendor assistant, runs a retrieval chatbot over its own documents, or is building AI features into a product. Petronella Technology Group delivers this work as part of our AI practice for organizations in Raleigh, Durham, Cary, and across the Triangle, and for regulated businesses nationwide through our AI services team.
The 2026 OWASP LLM Top 10 at a Glance
Here are the ten risks in OWASP's 2026 order. Each row gives a one-line meaning plus the single control we would put in place first. Select any risk name to jump to its full section.
| ID | Risk | What it means in plain English | Primary control |
|---|---|---|---|
| LLM01:2026 | Prompt Injection | Text, images, or audio the model reads change what it does, against the developer's intent. | Assume the injection will succeed and limit what the model can reach and do. |
| LLM02:2026 | Sensitive Information Disclosure | The AI system reveals confidential, regulated, or proprietary data through an answer, a log, or another channel. | Enforce authorization before retrieval and minimize what enters the context. |
| LLM03:2026 | Excessive Agency | The model has more tools, permissions, or autonomy than its job requires, so a bad output becomes a bad action. | Least privilege for every tool, with human approval on consequential actions. |
| LLM04:2026 | Supply Chain | A third-party model, adapter, dataset, or package is vulnerable, tampered with, or not what it claims to be. | A signed inventory of models and components from verified sources. |
| LLM05:2026 | Data and Model Poisoning | Someone corrupts the data or model artifacts the system learns from or retrieves, planting bias or a backdoor. | Validate and track the lineage of everything that is ingested. |
| LLM06:2026 | Unbounded Consumption | Nothing limits how much inference a user or attacker can trigger, so cost, availability, or the model itself is at risk. | Token-aware limits and hard spending caps that stop inference. |
| LLM07:2026 | Misinformation | The model produces wrong or unsupported output that looks credible enough to be acted on. | Ground and verify claims before a person or a workflow acts on them. |
| LLM08:2026 | Hidden Context Exposure | System prompts, tool schemas, and other behind-the-scenes context are extracted or inferred by a user. | Keep secrets and authorization logic out of the context entirely. |
| LLM09:2026 | Vector and Embedding Weaknesses | The similarity search layer behind retrieval leaks, is poisoned, or ignores who is allowed to see what. | Scope access inside the index query and separate indexes by trust level. |
| LLM10:2026 | Improper Output Handling | Model output is passed to a browser, database, shell, or other system without being validated first. | Treat model output as untrusted input and encode it for its destination. |
What Changed From 2025 to 2026
The same ten risks appear in both editions. What changed is the order and one name. Several entries also cover more ground than before.
| 2026 rank | Risk | 2025 rank | Movement | Scope change |
|---|---|---|---|---|
| LLM01 | Prompt Injection | LLM01 | Held first | Now explicitly covers cross-modal attacks hidden in images or audio. |
| LLM02 | Sensitive Information Disclosure | LLM02 | Held second | No rename or rank change. |
| LLM03 | Excessive Agency | LLM06 | Up three | Climbed to third as agent-style deployments spread. |
| LLM04 | Supply Chain | LLM03 | Down one | Now accounts for a promoted model artifact that is not what it claims to be. |
| LLM05 | Data and Model Poisoning | LLM04 | Down one | Now absorbs fine-tuning subversion. |
| LLM06 | Unbounded Consumption | LLM10 | Up four | Resource and cost exhaustion weighted more heavily by practitioners. |
| LLM07 | Misinformation | LLM09 | Up two | Same name, higher position. |
| LLM08 | Hidden Context Exposure | LLM07 (System Prompt Leakage) | Down one | Renamed and broadened beyond the system prompt. |
| LLM09 | Vector and Embedding Weaknesses | LLM08 | Down one | Same name, one position lower. |
| LLM10 | Improper Output Handling | LLM05 | Down five | Fell furthest, yet now spans insecure code that assistants generate. |
Agents are where the damage lands. OWASP describes the rise of Excessive Agency as the most consequential move on the list, and its reasoning matches what we see when we review deployments. A chatbot that can only talk produces embarrassing answers. An assistant that can send email or run code produces incidents, and so does one that can update records. For a business, the practical reading is that the question "what can this AI system do?" now matters almost as much as "what can it be tricked into saying?"
Cost exhaustion is now a mid-table risk, not a footnote. Unbounded Consumption moved from last place to sixth. Organizations paying per token for reasoning models and multi-step workflows have learned how fast the bill grows. One abusive session can generate a bill or an outage quickly. So can a stolen API key or a runaway loop. If your finance team has no spending cap on AI usage, this move is addressed to you.
System prompt leakage grew into hidden context. The 2025 entry focused on the system prompt. The 2026 entry, Hidden Context Exposure, covers everything an application quietly places in front of the model. That includes developer instructions and retrieved policy text. It also includes tool schemas and workflow rules. The lesson is the same but wider. Nothing in the context window should be treated as a secret, and nothing in it should be the only thing enforcing a security decision.
A lower rank is not a lower obligation. Improper Output Handling dropped to tenth, yet it now includes the insecure code that coding assistants generate at scale, which touches nearly every software team. Supply Chain and Data and Model Poisoning each slipped one place while taking on new scope. Treat the order as a guide to where to start, and treat the full list as the definition of done.
LLM01:2026 Prompt Injection
Prompt injection happens when something the model reads changes its behavior in a way the developer never intended. That "something" can be a typed message, a retrieved document, the output of a tool, an entry in long-term memory, or, as the 2026 edition now states explicitly, instructions concealed in an image or an audio track. The root cause is structural: a language model receives instructions and data as one stream of tokens and has no built-in way to tell which parts are allowed to give orders.
OWASP is direct about the consequence. No reliable way to prevent prompt injection exists today, so defense has to be architectural. You design the surrounding system on the assumption that the model's instructions will eventually be overridden, then constrain what the model may do and where its output may go so that a successful injection does not become a successful breach. Our dedicated guide to prompt injection covers direct and indirect attack paths in more depth.
How it shows up
A Microsoft 365 Copilot style assistant summarizes an inbox. One inbound message contains hidden text telling the assistant to gather recent contract threads and include them in a reply or a link. A hiring workflow feeds resumes to a screening model. A candidate embeds white-on-white instructions that tell the model to rank the application first. A support bot reads a ticket whose body instructs it to issue a refund through the tool it has been given. Nobody typed anything malicious into the chat window.
Controls that work
- Give the model the minimum tools and data scopes its task needs, so a hijacked session has little to work with.
- Remove one leg of the dangerous combination: private data access, untrusted content, and an outbound channel in the same session.
- Mark and separate retrieved and third-party content from developer instructions, and treat it as data in every downstream step.
- Require human approval before consequential actions such as sending, deleting, paying, or changing permissions.
- Restrict outbound requests and automatic link or image rendering so context cannot be smuggled out.
- Screen inputs and outputs with classifiers, knowing these reduce attempts but will not stop a determined attacker.
- Log prompts, retrieved sources, and tool calls so an injection can be reconstructed afterward.
How we test it. We map every route by which content reaches the model. We also map every action the model can take and every channel its output can reach. Then we attack each route with direct and indirect payloads. Some are plain and some are encoded. Others are split across documents or embedded in images where the application accepts them. Model behavior is probabilistic. We rephrase and repeat each payload before we rate the finding. The report states what an injection achieved, not merely that the model could be talked out of its instructions.
LLM02:2026 Sensitive Information Disclosure
Sensitive information disclosure occurs when an LLM-integrated system exposes data that should stay private through a channel nobody authorized. Regulated records count, as do privileged files. Plain business secrets count too. The 2026 text stresses that the final answer is only one such channel. Tool-call arguments can reveal information. Reasoning traces can too. So can retrieved chunks and logs. Even measurable properties such as response timing leak. Each channel deserves the same classification and redaction rules as the answer itself.
OWASP points to two structural causes behind most cases. The first is oversharing upstream: drives with loose permissions and knowledge bases with no access scoping feed a retrieval system that then hands sensitive content to whoever asks, exactly as designed. The second is persistence: once data has shaped model weights or embeddings, deleting the source file does not remove it. The fix usually sits in the data layer, which is why a current data classification policy and enforced data protection controls matter more here than any prompt wording.
How it shows up
A company turns on an AI assistant across its file shares. An employee asks about salaries or a pending acquisition, and the assistant answers from a folder that was shared too broadly years ago. A medical practice pastes patient details into a consumer chatbot that has no business associate agreement behind it. That is why we steer healthcare clients toward HIPAA compliant AI designs. A defense subcontractor lets engineers summarize drawings in a public tool, placing controlled unclassified information outside its authorized boundary.
Controls that work
- Clean up permissions and classify data before connecting any assistant to file shares, mail, or a CRM.
- Enforce document and chunk level authorization inside the retrieval query, not after results come back.
- Send only the fields a task needs to an outside provider, and turn off features that append whole records automatically.
- Keep credentials, keys, and regulated data out of system prompts.
- Redact with trained classifiers and entity recognition alongside pattern matching, since patterns alone miss encoded or translated output.
- Scrub logs and traces before they reach monitoring tools, and encrypt data in transit and at rest.
- Enforce no-training and no-retention settings technically and contractually, not by policy text alone.
How we test it. We sign in as users at different privilege levels and ask the system for things each one should not see, then compare what each one gets back, from the answer itself to the retrieved chunks behind it. We review what the application sends to outside providers and what lands in logs. We also check whether summaries or translations surface more than the user requested. Findings are tied to the specific share or setting that caused the exposure, so the remediation is a permissions task with an owner.
LLM03:2026 Excessive Agency
Excessive agency is the weakness that lets an LLM-based system take a damaging action because a model output was unexpected or manipulated. Ambiguous output can do the same. The cause of the bad output is almost beside the point. It might be a hallucination, a poorly written prompt, an injected instruction, or a compromised tool. What turns it into harm is that the system was able to act on it.
OWASP breaks the root cause into three parts: excessive functionality (tools the system does not need, or tools that do more than the task requires), excessive permissions (tool identities with broader rights than necessary), and excessive autonomy (high-impact actions with nobody checking them). This entry moved from sixth to third in 2026. Filtering inputs and outputs is not the root control here. Scoping is. That scoping work is the core of our AI agent security and AI guardrails engagements.
How it shows up
A mailbox assistant only needs to read and summarize, but the connector it was given can also send and delete. One manipulated summary request becomes an outbound message from an executive's account. A customer support bot connects to the order database through a service account with full write access, when read access to one table would have done the job. A tool that was trialed during development and then abandoned is still registered and callable in production.
Controls that work
- Offer the model only the tools the use case requires, and remove anything left over from development.
- Trim each tool to the functions needed: a summarizer reads mail and does not send or delete it.
- Replace open-ended tools such as "run a shell command" or "fetch any URL" with narrow, purpose-built ones that validate their inputs against a strict schema.
- Grant each tool identity the least privilege possible in the downstream system, enforced by that system's own permissions.
- Run actions in the context of the requesting user so the AI system cannot exceed what that person could do.
- Put a human approval step in front of high-impact actions.
- Enforce authorization in the downstream systems themselves, never by asking the model to decide.
How we test it. We inventory every tool and service account the AI system can use and compare each against what the use case needs. Then we try to drive the system into using the surplus. The deliverable is a permission-by-permission list. Each line says whether to remove the permission or narrow it. Some get gated behind approval instead. When we build agents ourselves through our AI agent development services, the same list is written before the first tool is wired in.
LLM04:2026 Supply Chain
An LLM application depends on far more than code libraries. It depends on pre-trained models and the datasets behind them. It also depends on conversion tooling and serving frameworks. Hosting platforms belong on that list too. A weakness in any of them can undermine the application. OWASP's supply chain entry covers vulnerable or outdated components. It covers tampered or backdoored models and licensing exposure. New in the 2026 scope is the trust failure that occurs when a promoted model artifact is not what it claims to be.
Two points deserve attention from a business reader. First, a model file is difficult to inspect. Static scanning alone cannot establish that a model behaves safely, so provenance and integrity checks carry more weight than they do for ordinary software. Second, coding assistants have created a new variant of an old problem: they sometimes suggest package names that do not exist, and attackers can register those names in advance so that an unverified suggestion pulls in malicious code.
How it shows up
A developer downloads a popular open-weights model from a public hub because the name looked right. Nobody verifies the publisher or the file hash before it reaches production. A team signs up for an AI note-taking service without reviewing how it stores recordings. Nobody asks who its subprocessors are. Nobody checks whether customer content is used for training. An engineer accepts a dependency recommended by a coding assistant without confirming the package is real and is the intended one.
Controls that work
- Vet AI suppliers, including their terms and privacy policies, and reassess when those change. Our AI vendor security questionnaire is a starting point.
- Fold AI vendors into your existing third-party risk management program instead of treating them as an exception.
- Keep a signed, current inventory of models, adapters, datasets, and libraries, extending the software bill of materials idea to AI components.
- Use models only from verifiable sources, and check signatures and file hashes before anything is promoted.
- Scan and patch serving frameworks and dependencies, and apply the same discipline to development environments.
- Confirm every AI-suggested dependency exists and is the intended package before installing it.
- Evaluate and red team third-party models for your use case before adoption, and record the results in a model card.
How we test it. We build the inventory first, because most organizations do not have one: every model and dataset in use, plus every AI vendor and AI-related package. Each entry records its source and version. We then verify provenance and integrity where it can be verified. Vendor terms and data handling get a review. The surrounding components get scanned for known weaknesses. Gaps in provenance are reported as findings in their own right, since an artifact nobody can trace is a risk even when nothing is visibly wrong with it.
LLM05:2026 Data and Model Poisoning
Poisoning is the manipulation of data or model artifacts so that an AI system learns or retrieves something harmful. The result might be a bias or a weakness. It might also be a hidden trigger that changes behavior on command. OWASP notes that poisoning is no longer limited to training data in the traditional sense. It can occur anywhere data is ingested or reused. That covers pre-training and fine-tuning. It also covers embedding creation and retrieval pipelines. Model distribution is in scope too. The 2026 edition folds fine-tuning subversion into this entry.
What sets poisoning apart is the cost of the cure. A code flaw can be patched. A poisoned model may need retraining or outright replacement, and the system often appears to work normally in the meantime. Poisoning also does not require an attacker. Careless data hygiene and contaminated sources produce the same result. Organizations weighing customization options should read our comparison of RAG vs fine-tuning with this risk in mind, because the two approaches expose different stages of the pipeline.
How it shows up
A company fine-tunes a model on years of support tickets without screening them. Text submitted by outsiders becomes part of what the model learns. A knowledge base accepts uploads from many departments and partners. One altered procedure document begins steering every answer that draws on it. A feedback loop retrains a model automatically on user ratings, and a small group of users shapes its behavior gradually without anyone reviewing the incoming data.
Controls that work
- Track the lineage of datasets and models, and verify signatures at each stage of the lifecycle.
- Validate all incoming data and vet the parties that supply it.
- Use curated, domain-specific datasets for fine-tuning instead of whatever is at hand.
- Protect retrieval systems with trust boundaries, source scoring, and filtering of retrieved content.
- Version datasets so that changes can be traced and rolled back when a problem is found.
- Put human oversight and rate limits on automated retraining and feedback loops.
- Monitor outputs and training behavior for drift, and probe for hidden triggers after every tuning cycle.
How we test it. We trace who and what can write to each training set and index. Feedback channels get the same review. Then we attempt controlled insertions in a staging environment to see whether validation catches them and how far they propagate. For tuned models we run trigger-style probes and compare behavior against a known-good baseline. Our LLM fine-tuning services apply the same lineage and validation steps from the beginning, so a tuned model ships with a record of what it learned from.
Not Sure Which of These Apply to Your AI Deployment?
An AI security assessment inventories the AI systems you run, maps each one to the OWASP LLM Top 10, and ranks what to fix first. Scoping starts with a short call.
LLM06:2026 Unbounded Consumption
Unbounded consumption exists when an application allows excessive, uncontrolled inference. OWASP groups several outcomes under it. Service disruption is one and runaway cost is another. Theft of intellectual property through model cloning is a third. All share the same gap: no adequate control over how resources are used. The defining feature is cost asymmetry. A request that costs an attacker almost nothing can trigger computation that costs the operator a great deal.
The entry rose four places in 2026, and the reasons are familiar to anyone who has reviewed an AI invoice. Reasoning models with large output budgets raise the ceiling on what a single session can consume. Multi-step workflows that fan one request into many downstream calls raise it further. OWASP states plainly that limiting requests per second is no longer sufficient on its own. Limits need to understand tokens and cost. Where usage is steady and predictable, fixed-capacity options such as AI inference hosting or a self-hosted LLM change the exposure from a variable bill to a capacity question.
How it shows up
A public website chatbot has no per-user limit. Automated traffic sends long prompts around the clock and the month's AI budget is consumed in days. An API key is committed to a code repository. Someone else finds it and uses it to run their workloads on your account. An internal workflow enters a loop in which the model keeps calling a tool and re-reading the result, with no cap on steps.
Controls that work
- Apply rate limits and quotas per user, key, and session, measured in tokens and estimated cost as well as request counts.
- Estimate token usage before inference and reject oversized requests up front.
- Set hard spending caps per key, user, team, and account that halt inference, not thresholds that only send an alert.
- Cap the number of steps, tool calls, and queued actions a single request may trigger.
- Design for graceful degradation so heavy load reduces function instead of causing a full outage.
- Restrict what the application can reach on the network to limit extraction and exfiltration.
- Attribute cost continuously and alert on anomalies, feeding the signals into the same monitoring your security team already watches.
How we test it. With written permission and agreed ceilings, we send oversized inputs and loop-inducing tasks to confirm that limits exist and that they stop inference when reached. We review how API keys are stored and rotated, and whether spending caps are enforced or advisory. Usage anomalies are a detection opportunity too, so we check whether they reach your monitoring. That might be an internal team or our managed XDR service.
LLM07:2026 Misinformation
Misinformation, in OWASP's terms, occurs when an LLM or an application built on one produces wrong or misleading output that looks credible enough to influence a decision. Automated workflows can act on it too. The danger lies less in the model being wrong and more in the wrong output being trusted. Hallucination is one source. Stale context is another. Weak grounding and ambiguous prompts add more. Summaries that drop a critical exception round out the list. It can also be induced deliberately by someone who plants false material where the system will retrieve it.
The 2026 text treats this as a system-level failure, because model output increasingly drives things: it fills in forms, infers whether a condition has been met, and decides which step runs next. Overreliance is the amplifier. People and software both tend to treat fluent, confident, well-structured text as authoritative. For a regulated organization this becomes a governance issue as much as a technical one, which is why it features in our AI governance framework guidance.
How it shows up
A policy chatbot tells an employee that a benefit or exception applies when the current handbook says otherwise, because it answered from an outdated document. A contract summary leaves out a termination clause, and the reader signs off without opening the original. A customer service assistant misreads the refund terms and approves a request that the written policy does not allow.
Controls that work
- Ground answers in authoritative, current sources and show citations the reader can open.
- Separate generation from execution: check a claim before any system acts on it.
- Validate tool calls against real state, preconditions, and authorization before they run.
- Use groundedness and consistency checks instead of trusting the model's stated confidence.
- Require structured outputs with mandatory fields so that an omission is visible.
- Add approval workflows for high-impact decisions in legal, clinical, financial, and safety contexts.
- Label what has been verified and what is an assumption, and train staff to read AI output accordingly.
How we test it. We assemble a question set with known answers drawn from your own authoritative documents, including questions whose correct answer is "the documents do not say." We measure where the system fabricates and where it answers from stale content, and we trace whether any downstream step would act on that output unchecked. The results feed an AI audit record that shows reviewers how accuracy is measured and who is accountable for it.
LLM08:2026 Hidden Context Exposure
Hidden context exposure is the unauthorized extraction or reconstruction of the instructions and operational material an application places in the model's context but does not intend users to see. In 2025 this entry was called System Prompt Leakage. The 2026 name reflects a wider scope. Beyond the system prompt it covers developer instructions and retrieved policy text. Tool schemas count too, as do any other rules the application assembles behind the scenes.
OWASP's guidance is to design as though hidden context is discoverable. If revealing it would cause little or no security harm, the finding is informational. Severity climbs with what was put there and how much the application leans on its secrecy: internal rules and filtering criteria help an attacker aim, embedded credentials are a serious exposure, and reliance on hidden instructions to enforce authorization is a design flaw. Exposure also feeds the other entries, since leaked rules sharpen injection attempts and leaked tool schemas reveal what an attacker could try to invoke. Our LLM security practice treats the context window as public by default for this reason.
How it shows up
A developer places an API key in the system prompt so the model can pass it to a tool. A user asks the bot to repeat its instructions and receives the key. A sales assistant's hidden instructions contain discount thresholds and escalation rules. A customer extracts them and negotiates against them. An application relies on the line "only answer administrators" in its prompt as its sole access control, with no check in the code behind it.
Controls that work
- Keep credentials, connection strings, tokens, and security-critical configuration out of prompts and hidden context.
- Hold secrets in systems the model cannot read, and let deterministic code use them on the model's behalf.
- Enforce authorization and privilege separation in code that is auditable, independent of the model.
- Enforce content rules with external guardrails instead of relying on instructions in the prompt.
- Separate tasks that need different access levels into different authorization contexts.
- Review prompts, retrieved policy text, and tool schemas as if they will be published, and remove what would hurt.
How we test it. We attempt extraction through direct requests and through translation tricks. Multi-turn approaches follow. Then we rate severity by what the recovered context contains and what depends on it. The more valuable half of the test is a design review: we read the prompts and configuration for secrets and for any security decision that exists only as an instruction. Fixes are written into the build process through secure AI development practices so the pattern does not return in the next release.
LLM09:2026 Vector and Embedding Weaknesses
Most business AI projects use retrieval-augmented generation (RAG): documents are converted into numerical representations called embeddings and stored in a vector database. Similarity search then matches them to questions. The same machinery sits behind vector-backed assistant memory and semantic caches. OWASP's point is that whenever similarity search decides what the model sees, the embedding layer becomes part of the application's trust boundary.
These weaknesses are distinct from prompt injection because they exploit how similarity search works, not how the model follows instructions. OWASP offers a compact way to remember the failure modes: poisoning makes the system wrong and inversion makes it leak. Jamming makes it silent. Access-control failure makes it indiscriminate. Many of these succeed even when the retrieved content contains no malicious instructions at all. Getting the architecture right at the start is far cheaper than retrofitting it, which is the premise of our RAG implementation services.
How it shows up
A RAG chatbot puts HR files and finance records into one shared index with everything else. It filters results in the application after the search has already run across everything. A multi-client portal uses one index for all customers. Result counts and scores in one customer's queries reveal that documents on a certain topic exist for another customer. Web content scraped for convenience shares an index with confidential internal procedures. A crafted external page starts winning retrieval for common questions.
Controls that work
- Enforce tenant and user scoping inside the index query, validated on the server, never as a filter applied afterward.
- Apply access control at the chunk level, since a mostly public document can contain one confidential paragraph.
- Keep content of different trust levels in separate indexes instead of relying on tags within a shared one.
- Normalize content before embedding by stripping hidden characters and invisible text.
- Record provenance for every embedding so a compromised batch can be found and invalidated.
- Authenticate and rate limit embedding and search endpoints, and do not return raw similarity scores to clients.
- Watch for anomalies at ingest and retrieval, such as new vectors that match an unusually wide range of queries.
How we test it. We query the retrieval layer as different users and tenants and look for anything that crosses a boundary, including indirect signals such as result counts and response timing. We insert marked test documents to see whether they can capture retrieval for unrelated questions, and we review how the index is partitioned and where the access decision is made. For the most sensitive collections, we often recommend a private LLM deployment with physically separate indexes.
LLM10:2026 Improper Output Handling
Improper output handling is the failure to check and sanitize model output before it is passed to another component. Because model output can be steered by whoever influences the prompt, handing it unchecked to a browser or a shell is similar to giving that person indirect access to those systems. Databases and email templates carry the same exposure. The classic results are well-known web and application flaws. Cross-site scripting and request forgery top the list. Query injection and path traversal follow. Privilege escalation and remote code execution sit at the severe end.
This entry is about unsafe use of output, which is different from Misinformation, where the output is simply wrong. It fell from fifth to tenth in 2026 while its scope grew to include the insecure code that AI assistants generate at scale. It also covers a quieter exfiltration route: chat interfaces and development tools that automatically fetch an image or link referenced in model output, sending context data to an outside server in the request. In practice this is application security applied to a new source of untrusted input, so it belongs in the same program as web application penetration testing and API penetration testing.
How it shows up
A reporting tool lets staff ask questions in plain English and turns them into database queries. It runs those queries directly with a privileged account. A chatbot renders model output as live markup in a customer portal, so a crafted response executes script in another user's browser. A coding assistant produces a working function that concatenates user input into a query, and it is merged without review because the tests pass.
Controls that work
- Treat the model as an untrusted user and validate its output before any backend function consumes it.
- Encode output for its destination: HTML, script, query, file path, or command line each need their own handling.
- Use parameterized queries for every database operation that involves model output.
- Apply a strict content security policy wherever generated content is displayed.
- Strip terminal control characters before output is written to consoles, logs, or development tools.
- Disable automatic rendering of images, link previews, and embedded frames from model output, or restrict fetches to an approved list.
- Put AI-generated code through the same review, scanning, and testing as code written by a person.
How we test it. We trace every place model output goes after it leaves the model and test each sink the way we would test any input field: markup and script payloads for renderers and query fragments for data layers. File and system calls get path and command fragments. We also check whether the interface will fetch remote resources named in a response. For teams shipping AI-assisted code, we review how generated code enters the pipeline.
Turn the Top 10 Into a Tested Control Set
Reading the list is the easy part. Petronella Technology Group's LLM security team tests your application against all ten entries and helps you fix what fails. Then we retest.
Where the LLM Top 10 Stops: Agents and the Agentic Top 10
OWASP draws one boundary in the 2026 edition that it says matters more every year. The LLM Top 10 owns the risk when the model is a component inside your application: it receives input and produces output, and your code decides what happens next. Once the model becomes an actor with tools it can call and memory it carries between sessions, OWASP points readers to a separate document, the OWASP Top 10 for Agentic Applications.
The two lists are meant to be used together. OWASP notes that many real cases sit right on the boundary, and that neither list covers that ground alone. Several LLM Top 10 entries already lean toward the agentic side: Excessive Agency is about tools and permissions, Prompt Injection becomes far more serious when output drives actions, and Unbounded Consumption is amplified when one request fans out into many.
For planning purposes, ask one question of each AI system you operate: does a person or deterministic code review the model's output before anything happens, or does the model decide and act? If it is the first, the LLM Top 10 is your primary reference. If it is the second, the LLM Top 10 is still the starting point. Add agent-specific analysis on top. Our AI agent security work covers identity and tool governance for systems on the actor side of the line, and AI red teaming exercises both sides in a single engagement so that the handoff between them is tested too.
Mapping the OWASP LLM Top 10 to Frameworks You Already Answer To
The table below is our practitioner mapping at the family level, intended to show where each LLM risk fits in programs you already run. It is not an official OWASP crosswalk and it does not replace a control-by-control assessment.
| 2026 entry | NIST AI RMF functions | NIST SP 800-171 families | HIPAA Security Rule safeguards | SOC 2 common criteria categories |
|---|---|---|---|---|
| LLM01 Prompt Injection | Map, Measure, Manage | System and Information Integrity; Access Control | Technical | Logical and Physical Access Controls; System Operations |
| LLM02 Sensitive Information Disclosure | Govern, Map, Manage | Access Control; Media Protection; Audit and Accountability | Administrative; Technical | Logical and Physical Access Controls; Communication and Information |
| LLM03 Excessive Agency | Govern, Map, Manage | Access Control; Identification and Authentication; Configuration Management | Administrative; Technical | Logical and Physical Access Controls; Control Activities |
| LLM04 Supply Chain | Govern, Map | Risk Assessment; Configuration Management; System and Information Integrity | Administrative | Risk Mitigation; Change Management |
| LLM05 Data and Model Poisoning | Map, Measure, Manage | System and Information Integrity; Configuration Management; Access Control | Administrative; Technical | Change Management; Monitoring Activities |
| LLM06 Unbounded Consumption | Measure, Manage | System and Communications Protection; Audit and Accountability | Administrative; Technical | System Operations; Monitoring Activities |
| LLM07 Misinformation | Govern, Measure, Manage | Risk Assessment; Awareness and Training | Administrative | Risk Assessment; Control Activities |
| LLM08 Hidden Context Exposure | Map, Manage | Access Control; Configuration Management; Identification and Authentication | Technical | Logical and Physical Access Controls; Change Management |
| LLM09 Vector and Embedding Weaknesses | Map, Measure, Manage | Access Control; System and Information Integrity; Audit and Accountability | Technical | Logical and Physical Access Controls; System Operations |
| LLM10 Improper Output Handling | Measure, Manage | System and Information Integrity; Configuration Management | Technical | Change Management; System Operations |
NIST AI RMF and ISO/IEC 42001. The NIST AI Risk Management Framework organizes AI risk work into four functions: Govern, Map, Measure, and Manage. The LLM Top 10 gives the Map and Measure functions something concrete to map and measure. Our NIST AI RMF guide explains how the pieces fit. ISO/IEC 42001 defines a management system for AI, and an organization pursuing ISO 42001 certification can use the ten entries as a structured input to its AI risk assessment and treatment planning.
Defense contractors. An AI system that handles controlled unclassified information sits inside the assessment boundary like any other system. The families behind NIST 800-171 compliance still apply to it, and our CMMC compliance guide explains how scoping decisions are made. The LLM Top 10 helps you find AI-specific ways those familiar families can fail.
Healthcare, service providers, and state law. For covered entities and business associates, AI tools that touch protected health information fall under the same HIPAA Security Rule safeguards as the rest of the environment, as described in our HIPAA compliance resources. Service organizations can align LLM findings with the trust services criteria covered in our SOC 2 controls overview. State AI laws are adding their own duties, and our Colorado AI Act page is a useful reference for organizations tracking that direction.
A 30-60-90 Day Plan to Address the LLM Top 10
A realistic sequence for a small or mid-size organization. The first thirty days are about knowing what you have, the next thirty about fixing what matters most, and the last thirty about proving it and keeping it that way.
Days 1 to 30: Inventory AI Use
List every AI tool and integration in use. Include unapproved ones and in-house projects. Shadow AI detection finds what nobody reported. Technical controls can block unapproved AI tools, and an AI acceptable use policy tells staff what is allowed.
Days 1 to 30: Threat Model
Diagram the inputs and outputs of each system. Then mark what the model can touch and who could influence each path. Structured threat modeling turns ten abstract entries into a short list of risks that are real for you.
Days 31 to 60: Fix the Top Three
Start with Prompt Injection, Sensitive Information Disclosure, and Excessive Agency. In practice that means cleaning up data permissions and trimming service account rights. Consequential actions get an approval step.
Days 31 to 60: Test
Verify the fixes by attacking them. Combine AI red teaming with conventional penetration testing of the surrounding application, inside a wider AI security assessment or AI risk assessment.
Days 61 to 90: Monitor and Respond
Send AI logs and usage anomalies to monitoring such as managed XDR, and write an AI incident response procedure so the first AI incident is not also the first time anyone has discussed one.
Days 61 to 90: Govern
Assign an owner for AI risk and set a review schedule. Record each decision. AI governance consulting or a virtual CISO can carry that role where there is no full-time security leader.
The plan repeats. New AI features and new vendors are reasons to return to step one. So is each revision of the OWASP list. Organizations that keep the inventory current find the later steps get shorter each cycle, because most of the work lies in knowing what exists and who owns it.
Private and Self-Hosted LLMs: Which Risks Shrink, Which Stay
Running a model on infrastructure you control changes the risk picture. It does not erase it, and anyone who tells you otherwise is selling hardware.
Risks that shrink
Third-party data exposure (part of LLM02). Prompts and documents stay on systems you operate, and so do the outputs, so there is no outside provider retaining or training on them.
Some supply chain exposure (part of LLM04). You choose and pin the model version, and a provider cannot change it underneath you. You still have to verify what you downloaded.
Consumption billing exposure (part of LLM06). Fixed hardware replaces a per-token bill, so abuse shows up as slow service instead of an open-ended invoice.
Risks that stay
Prompt Injection (LLM01). A self-hosted model reads instructions in content exactly as a hosted one does.
Excessive Agency (LLM03). Tools and permissions are your design decisions wherever the model runs.
Data and Model Poisoning (LLM05). Your corpus and tuning data still need validation. So do the open weights you downloaded.
Improper Output Handling (LLM10). Output is untrusted input to downstream systems regardless of where it was generated.
Self-hosting also moves some responsibilities onto you. OWASP observes that open-weights deployments cannot lean on a provider's rate limits to slow extraction attempts, and patching the serving stack becomes your job. Where the model lives does not change internal disclosure or retrieval scoping. Hidden context and misinformation stay the same too.
For many regulated organizations the trade is still worth making, because third-party data exposure is the risk their contracts and regulators care about most. Our private AI solutions and on-premise AI deployments are built for that case, and our self-hosted LLM guide walks through the options, including lightweight runtimes such as Ollama for smaller teams. Whichever route you choose, the controls in this page still apply, and our enterprise AI security service covers them whether the model is hosted by a provider or runs on your own hardware.
Three Ways to Address the OWASP LLM Top 10: An Honest Comparison
Each route is legitimate. The right one depends on how much AI you run and how regulated you are. The skills you already have in-house matter as well.
| Consideration | Do it yourself with the OWASP document | Generic penetration testing firm | Petronella Technology Group |
|---|---|---|---|
| Best fit | Teams with in-house application security and machine learning experience and a small number of AI systems. | Organizations that mainly need the web and API layer around an AI feature tested. | Regulated small and mid-size organizations that need testing, remediation help, and audit-ready documentation from one team. |
| Strengths | No outside spend, and your team builds lasting knowledge of its own systems. The OWASP document is free and thorough. | Mature methodology for conventional vulnerabilities, including the output handling issues in LLM10. | AI-specific testing combined with compliance mapping, private AI engineering, and forensic experience. |
| Limits | Hard to attack your own design objectively, and the work competes with delivery deadlines. | AI-specific depth varies widely from firm to firm. Ask how they test retrieval, tools, and hidden context. | A security and compliance firm, not a model research lab. We do not publish original model research. |
| Coverage of the ten entries | Depends on available skills. Supply chain and embedding entries are often the hardest to self-assess. | Often strongest on LLM10 and the surrounding application, lighter on governance entries. | All ten entries, plus the agent boundary where it applies. |
| Compliance evidence | You write the mapping to your frameworks yourself. | A findings report, usually without framework mapping. | Findings mapped to the frameworks you report against, with supporting policy and evidence documentation. |
| Remediation | Owned entirely by your team. | Recommendations, with fixes left to you. | Recommendations, hands-on remediation support where wanted, and a retest. |
Many organizations combine these. A capable internal team can run the inventory and first-pass review using the OWASP document, then bring in outside testers for the parts where independence matters. If you already work with a penetration testing firm you trust, ask them the questions in the "Limits" row before assuming AI is in scope.
How Petronella Technology Group Assesses LLM Applications
Six steps, the same whether the system is a vendor assistant connected to your data, a retrieval chatbot, or a custom application.
Scope and Inventory
We identify the AI systems in use and the data each can reach. We also list the vendors involved and the obligations that apply to that data.
Map Inputs, Outputs, and Actions
For each system we document every path into the model and every destination for its output. Every tool or permission it holds goes on the same record.
Threat Model Against the Ten Entries
Each entry is marked applicable or not, with reasons, so testing time goes where the exposure is.
Test
Hands-on attack and review work for every applicable entry, using the methods described in the sections above.
Remediate and Retest
Findings are ranked by business impact. After fixes are in place, we attack the same paths again with varied payloads.
Document the Evidence
Findings, controls, and policies are mapped to your frameworks and recorded so an auditor or customer can follow them.
The work is led by Craig Petronella, founder of Petronella Technology Group, Inc. Craig is a CMMC Certified Registered Practitioner (CMMC-RP), an NC Licensed Digital Forensics Examiner (License# 604180-DFE), and MIT-certified in cybersecurity, AI, blockchain, and compliance. The firm was founded in April 2002, has held a BBB A+ rating since 2003, and is a CyberAB Registered Provider Organization (RPO #1449). You can read more on our about page.
The forensic background shapes how we assess. A licensed examiner asks what evidence would exist after an incident, so logging and reconstruction are tested alongside prevention, drawing on our digital forensics practice. For documentation we use Compliance Armor®, our compliance documentation platform, to keep policies and evidence together with the gap analysis instead of scattered across spreadsheets.
As Craig Petronella details in Beautifully Inefficient, AI is most valuable when it works alongside human creativity and judgment, which is the same reasoning behind keeping a person in the loop for consequential AI actions. As Craig Petronella details in How Hackers Can Crush Your Business, attackers go after the weaknesses smaller organizations leave open, and a newly connected AI assistant is one more place to look. Both titles are listed on our books page.
"Reliable, trustworthy, and efficient. I've worked with a lot of companies, but this one stands out for their commitment to quality service."Maru Khuy, TrustIndex verified review
Petronella Technology Group is rated 4.7 across 92 verified TrustIndex reviews and 5.0 across 15 Google reviews.
Sources
- OWASP GenAI Security Project: OWASP Top 10 for LLM Applications 2026: the primary document for the 2026 list, published August 3, 2026.
- OWASP GenAI Security Project: LLM Top 10 project page: the project home, with the 2025 and 2023/24 editions for comparison.
- NIST AI Risk Management Framework: the governance framework the 2026 list maps its entries to.
- NIST AI 600-1: Generative AI Profile: NIST's companion profile for generative AI risks.
- MITRE ATLAS: the adversarial tactics and techniques knowledge base for AI systems.
- MITRE Common Weakness Enumeration (CWE): the software weakness catalog referenced by the 2026 mappings.
- Invicti: OWASP LLM Top 10 2026, what's new: an independent entry-by-entry summary of the 2025 to 2026 moves.
- Cloud Security Alliance research note on the 2026 LLM Top 10: commentary on how incident data shaped the new order.
Craig Petronella
Craig Petronella founded Petronella Technology Group, Inc. in 2002. He is a CMMC Registered Practitioner (CMMC-RP), Cisco CCNA, Certified Wireless Network Expert (CWNE) and North Carolina Digital Forensic Examiner (License 604180-DFE), and the author of 16 books. He leads Petronella Technology Group's AI security and private AI work, and his team assesses LLM applications for regulated organizations.
OWASP LLM Top 10 Questions
What is the OWASP LLM Top 10?
What is the latest version of the OWASP Top 10 for LLM Applications?
What changed in the OWASP LLM Top 10 for 2026?
What is the number one risk in the OWASP LLM Top 10?
What is excessive agency?
Is the OWASP LLM Top 10 a compliance requirement?
Does the OWASP LLM Top 10 apply if we only use tools like Microsoft 365 Copilot or ChatGPT?
How do you test an application against the OWASP LLM Top 10?
Find Out Where Your AI Stands Against the 2026 List
Tell us what AI tools and applications you run. We will tell you which of the ten risks apply and what to fix first. We will also tell you what evidence your auditors and customers will expect to see. Based in Raleigh and serving regulated organizations nationwide.
Written by Craig Petronella, CMMC Registered Practitioner and NC Licensed Digital Forensics Examiner (License 604180-DFE), founder of Petronella Technology Group, Inc. in Raleigh, North Carolina.
Last Updated: November 16, 2026 | Petronella Technology Group, Inc. | 5540 Centerview Dr., Suite 200, Raleigh, NC 27606 | 919-348-4912 | info@petronellatech.com