AI application security: match what your chatbot or agent does to the guides, test packs and evidence that fit it
Ten guides in this library each cover one part of an application built on a large language model, from the text a user types to the bill the model runs up.
Two more map those parts to OWASP's list and plan a test across them. The selector below asks eight questions about your own application, in the order a request travels through it, and for each one names the guides that cover it, the test pack each guide gives you, what to have ready and the evidence to keep.
On this page
Pages in this section
12 pages
Prompt injection is text that talks an AI chatbot out of the rules its owner set. This guide covers the direct kind, typed into the chat by the person using the bot: the forms an attack takes, where the controls that limit the damage sit, and a versioned set of harmless test cases to run against a bot you own.
Indirect prompt injection hides instructions in the web pages, emails, PDFs, product reviews and tool results an AI chatbot or agent reads, so the attacker does not need to type anything into the chat. This guide shows where those instructions arrive, how to test for them with harmless canaries, how to trace an action back to the content that caused it, and which controls limit the damage. The fixture corpus below is yours to use on a bot you own or are authorised to test.
A retrieval pipeline is an access-control system that feeds a language model. This guide covers where the permission check has to sit, how tenants stay apart in a shared index, what the index and its caches keep, and what happens when a document is deleted or its permissions change. The two-tenant test pack below is yours to run on a test copy of a system you own or are authorised to test.
A guide to securing Model Context Protocol servers and the clients that connect to them, written against the 2026-07-28 revision of the specification. It covers tool poisoning, tool definitions that change after approval, token audience and scopes, local transports, user consent and audit logs, and comes with a mock server matrix you can run as a review checklist.
How to design and test the permissions on each tool an AI agent can call. One synthetic document tool, split into read-only, write and delete variants, shows what each variant needs in OAuth scope, schema arguments, record access and confirmation, and which server-side check refuses the call when the model sends the wrong one. The permission-diff worksheet and its denied-action fixtures are yours to copy.
An AI agent works towards a goal over many steps. It plans, calls tools, keeps notes between sessions, passes work to other agents and decides when it has finished, and each of those is a point where the workflow can be turned. This guide maps them for one illustrative business workflow, with a bounded test fixture, the safe behaviour to expect and an evidence log for every step.
A system prompt carries more than instructions. Whatever else is placed in it, such as a key, a customer's details or a discount rule, travels with it. This guide explains how that content leaves a chatbot by five routes, why keeping the prompt secret does not protect it, and gives you a prompt asset register with harmless extraction fixtures to run on a bot you own.
A model's reply is data from outside your application, whoever shaped it. This guide follows one reply into the five places it can land, HTML, Markdown, URLs, JSON and SQL, shows what each receiving system has to do with it, and gives you a fixture suite that tests each path with harmless markers.
A language model application copies business data into more places than the chat window shows: prompts, retrieved documents, fine-tuning sets, logs, caches and evaluation sets. This guide maps each one, explains how data leaks back out of it, and gives you a data-lineage worksheet and a canary-record protocol to run on a system you own or are authorised to test.
An AI feature billed per token turns every extra request, longer prompt and longer answer into cost. This guide shows how one request multiplies into a large bill, why the limits on your provider account count all your users together, and where per-user quotas, tenant budgets, concurrency limits, alerts and a kill switch have to sit. The token-budget model at the end copies straight into a spreadsheet.
The OWASP Top 10 for LLM Applications 2025 names ten security risks for software built on large language models. This page explains each one in plain terms, points to the guide on this site that covers it in depth, and gives a dated crosswalk: what to have in place, the evidence that shows it, and one harmless regression check per risk.
AI red teaming means different things to standards bodies, security groups and model makers. This guide sets their definitions side by side, separates testing a model from testing the chatbot or agent your business runs, and gives you a test-plan template, with a worked example, for the part you own.
AI threat-model selector: eight questions, twelve guides and their test packs
One row for each question about your application, in the order a request travels through it: text typed in, content the model reads, tools it calls, agents that act over several steps, where the reply lands and who pays, then what the application holds and copies, and how to plan a test. Answer each question for your own application; a yes names the guides that cover it.
How to use itHide the instructions
Every cell restates its guide no more strongly than the guide does, and names an OWASP entry only where the guide names it. Counts are taken from each asset as published. The addresses in the third column are linked under Pages in this section. Run a test pack only on an application your business owns, or one whose owner has authorised the test in writing.
8 rows
Question about your application
What a yes opens up, in the guide's own terms
1. Direct prompts. Can the person using it type instructions straight into the conversation?
- What a yes opens up, in the guide's own terms
- Direct prompt injection: the user's own input changing what the model does, whether someone crafts it on purpose or an ordinary message trips it by accident. The guide sorts attempts into seven groups, from text claiming to outrank your instructions to a shortcut agreed early in a chat and used several turns later, and builds its cases around what the bot can reach: customer data, an action, or a commitment such as a promised refund.
- Guide, address and the OWASP entry it names
- Prompt Injection, /web-security/prompt-injection. Names LLM01:2025 Prompt Injection. It tags cases that guard data LLM02:2025 Sensitive Information Disclosure or LLM07:2025 System Prompt Leakage, and cases that guard actions LLM06:2025 Excessive Agency.
- Test pack in the guide, counted
- A table: the direct prompt injection regression set, version 1.0, with 19 cases by 6 columns. Seventeen are attack cases in the seven groups and two are benign controls that a careful bot should answer normally. It is written for an invented homewares support chatbot with four rules and three tools, using harmless markers and two synthetic test customers.
- Have ready before the first run
- A test copy of the bot to plant the fixtures in: a canary line and an invented staff-only code in the instructions, and Test Customers A and B. Logging on that copy of the full request sent to the model provider, every tool call with its arguments, the server's response to each and the returns queue. If the bot is built on a hosted platform or calls a model provider, their terms on testing, read before you start.
- Evidence the guide tells you to keep
- Violations observed out of runs completed for each case: ten runs where customer data, an action or a commitment is protected, and five where only wording is. Each recorded run carries the set version and case IDs, the bot build (model and version, a version or hash of the instructions, the tool list with permissions, filter settings), the date and environment, inconclusive runs and where the transcripts and logs are kept.
2. Retrieved content. Does it read anything it did not write: web pages, emails, uploaded files, reviews, tool results or your own document store?
- What a yes opens up, in the guide's own terms
- Two separate problems, with a guide each. Indirect prompt injection: an instruction arriving inside content the model reads, so the attacker does not need to join the conversation, through five channels (web pages, emails, PDFs, product reviews and tool results). Retrieval as access control: who may retrieve which document, how tenants stay apart in a shared index, what the index and its caches keep, and what happens when a document is deleted or its permissions change.
- Guide, address and the OWASP entry it names
- Indirect Prompt Injection, /web-security/indirect-prompt-injection. Names LLM01:2025 Prompt Injection. RAG Security, /web-security/rag-security. Names LLM08:2025 Vector and Embedding Weaknesses, and cites LLM02:2025, LLM07:2025 and LLM06:2025 on why the filtering should not be left to the model.
- Test pack in the guide, counted
- Indirect: a text template, the fixture corpus, version 1.0, in five parts: canary rules with synthetic records; five fixtures (a web page, an email, a PDF, a product review and a tool result), each with three canary placements; the expected behaviour for three tasks (retrieval, summarisation and tool invocation); an evidence record for each run; and rules for reading a result. Every name, order and address in it is invented. RAG: a text template, the two-tenant access test pack, version 1: two invented businesses sharing one RAG product, six test accounts, nine synthetic documents and 18 tests in six groups (filtering, cross-tenant queries, citations, caches, deletion and permission changes), with a results sheet.
- Have ready before the first run
- Indirect: a test copy of the bot connected to test records, test inboxes and stub or sandboxed tools; a test host for the web page and a staging copy of the store for the review; and an application that records, for each model call, the identifiers of every piece of content in the model's context. Each fixture's clean twin runs first. RAG: the nine documents loaded into a test copy of your knowledge base through your normal ingestion path; a retrieval trace that records the document IDs handed to the model, which the guide says to add before anything else if the pipeline cannot yet show them; the raw API response where you can keep it; and your developer's read access to the test index and caches for the deletion count.
- Evidence the guide tells you to keep
- Indirect: one evidence record per run, with the corpus version, the bot under test, fixture and placement, the fixture file's hash, the content IDs in the model's context, where any marker turned up, each tool call, what any confirmation showed and who decided, the notes and messages on the synthetic orders and test inboxes, and a result of violation observed, no violation observed, inconclusive or not applicable. RAG: for each test, the document IDs observed on each of three runs, marker codes found in the answer, citations or raw response, and pass or fail; for deletion and permission changes, when the change was made and when the document stopped appearing.
3. Tool calls. Can the model call tools that read or change records, directly or through an MCP server?
- What a yes opens up, in the guide's own terms
- Each tool's permissions: which tools the agent is offered, the OAuth scope on the token, the arguments the schema admits, the records the server will act on, whether a person confirmed, and the server-side check that refuses a wrong call. For the Model Context Protocol, what a server exposes and what a client lets it do: tool poisoning and shadowing, definitions that change after approval, tokens accepted for another service, scopes wider than the job, local servers and local HTTP transports, links a server supplies, consent and audit logs.
- Guide, address and the OWASP entry it names
- AI Tool Permissions, /web-security/ai-tool-permissions. Names LLM06:2025 Excessive Agency, with LLM07:2025 System Prompt Leakage, and API1:2023, API3:2023 and API5:2023 from OWASP's API security list. MCP Server Security, /web-security/mcp-server-security. Names no LLM category by number, and is written against the 2026-07-28 revision of the MCP specification.
- Test pack in the guide, counted
- Tool permissions: a table, the permission-diff worksheet, 12 rows by 4 columns, comparing read, write and delete variants of one document tool on a synthetic document service with invented accounts and documents. Its last three rows are denied-action fixtures, one for each variant in each row, nine in all. MCP: a table, the mock server and client test matrix, 15 rows by 6 columns, built on an invented mock server, mock-notes, and a second, mock-weather, with harmless marker strings in place of instructions that move data.
- Have ready before the first run
- Tool permissions: the tools your agent actually receives, taken from the tool list each token gets or the definitions your code sends; test accounts and test records; and each account's own token, because every fixture is called against the tool server directly first and then repeated through a test copy of the agent. MCP: a baseline of the full tools/list response for each test identity, with a hash of every definition and the client's approval state; for the HTTP rows, a test authorisation server issuing tokens for two resources; and a listener you control, with client, server and listener logs kept for every run.
- Evidence the guide tells you to keep
- Tool permissions: for each fixture, the refusal set against the one expected; proof nothing changed (the document's version number or content hash before and after, and for a delete, the document still present); a log entry naming the user, tool, document and reason; and the exact inputs, so it reruns unchanged. MCP: the evidence column of each row, such as tool definitions as the client received them, hashes before and after a change, screenshots of approval prompts, requests and responses with token values redacted, and log extracts that say which server, tool, arguments, user and result.
4. Agent permissions. Does it work towards a goal over several steps, keep notes between sessions, pass work to other agents or wait for a person's approval?
- What a yes opens up, in the guide's own terms
- Six points where a multi-step workflow can be turned: goal hijacking, a plan relied on after the facts behind it changed, memory poisoning, messages between agents that look internal, the handoff to a person, and stop conditions. The guide pairs them with four limits it says an agent needs that a single-turn chatbot does not: a budget on steps and spend, approval before any action with effects, a way to stop it, and a record that lets someone reconstruct what it did.
- Guide, address and the OWASP entry it names
- Agentic AI Security, /web-security/agentic-ai-security. Names entries from OWASP's separate Top 10 for Agentic Applications for 2026, and no LLM category by number.
- Test pack in the guide, counted
- A table: the multi-step agent scenario map with evidence log, 13 rows by 8 columns, for an illustrative supplier-invoice workflow at a fictional building-supplies wholesaler with four cooperating agents. Each row gives a workflow step, what could go wrong, a bounded fixture and the safe behaviour to expect, and the last four columns are the evidence log: actions attempted, approved, blocked and rolled back.
- Have ready before the first run
- The nine items the guide puts in place before the first run, including the agent owner's written approval naming the workflow, the environment and what the agents may do; a test environment with the same agents, connected to an accounting sandbox or a test company file; synthetic records carrying markers; test inboxes with outbound email captured; an outbound allowlist; a low spending limit; a step budget and a stop switch, with the stop switch tested first; and a snapshot of the test data and memory store before each run.
- Evidence the guide tells you to keep
- For each action: run ID, step and timestamp; the goal identifier and the plan step; which agent acted and as which identity; the tool, its arguments with secrets and personal information redacted, and the response; the policy decision and the rule that made it; for approvals, who approved from which signed-in account, what the screen showed and when; memory reads and writes with their source; messages between agents and whether the receiver re-checked authority; and what was rolled back, with the check that confirmed it.
5. Output handling. Is a reply rendered as Markdown or HTML, in the chat window or anywhere else, or does it reach a staff screen, an email, a link, a structured action or a database query?
- What a yes opens up, in the guide's own terms
- Model output treated as untrusted input by each system that receives it: HTML pages and emails, Markdown in a chat widget, URLs the model writes or your code builds, JSON that drives an action, and values or whole statements that reach SQL. The guide puts each fix in the receiving system rather than in instructions to the model.
- Guide, address and the OWASP entry it names
- LLM Output Handling, /web-security/llm-output-handling. Names LLM05:2025 Improper Output Handling, and notes that the same risk was LLM02: Insecure Output Handling in OWASP's 2023/24 list.
- Test pack in the guide, counted
- A table: the output-encoding test suite for model output, version 1.0, 18 cases by 9 columns. It sends synthetic outputs (fixtures F1 to F9, and a real order note as the benign control) through the HTML, Markdown, URL, JSON and SQL destinations of an invented landscape supplies yard's trade portal. Four columns record validation, contextual encoding, the schema check and a person's approval as they happened in the run.
- Have ready before the first run
- A way to put each fixture in place of the model's reply, through a stub of your model call or a recorded response; a test copy of the application with synthetic customers and products; a test inbox; a host you control in place of tester.example, with its access log switched on; and a test copy of the database with synthetic rows for the SQL cases. A few cases then run end to end through the real model.
- Evidence the guide tells you to keep
- The build (application commit or version, the Markdown library with its version and options, the email template version, the schema version and the database account each feature uses); each case ID with the exact fixture text and its destination; the four control columns as they happened; the evidence each row names, including the tester.example access log for the run window; and pass, fail or inconclusive for each case.
6. Cost controls. Is the model paid for per token, or can a request trigger a tool that charges per call?
- What a yes opens up, in the guide's own terms
- Consumption you pay for and did not intend, by five routes: a public chat box anyone can script, a free trial signed up for many times, automated use of a paid seat, a provider key shipped in browser code, and retry or tool loops in your own code. The guide traces one request's cost through six multipliers and sets out five controls on your server: a per-user quota, a tenant budget, a concurrency limit, an anomaly alert and a tested kill switch, with the provider's own limits as the backstop.
- Guide, address and the OWASP entry it names
- LLM Cost Abuse, /web-security/llm-cost-abuse. Names LLM10:2025 Unbounded Consumption, including its denial of wallet example.
- Test pack in the guide, counted
- A table: the token-budget model, 22 spreadsheet rows (rows 2 to 23) by 6 columns, with invented figures for a fictional help assistant in a business software product. Thirteen input rows, seven calculated rows with their formulas and two comparison rows set limits in place (column C) against limits missing (column D). The five synthetic abuse scenarios that check each control sit in the page body, not in the table.
- Have ready before the first run
- For the scenarios: a test environment with its own provider project or workspace and its own key; a low hard spending limit there, where your provider offers one, set before any test traffic; two invented test tenants with two test users each; low test values for every limit; and read access to the application's usage log and the provider's usage figures. Each scenario uses a handful of requests, and none sends a flood of traffic.
- Evidence the guide tells you to keep
- A usage log entry for every model call: request ID, the user and tenant taken from the session, the feature and the time; the model, with input and output tokens as the provider reports them; the amount reserved before the call and settled after it; the round and attempt number; the decision and the limit that made it; and for alerts and the kill switch, who was told or who switched, and when. The log's totals are reconciled against the provider's usage figures.
7. Held and copied data. What does it hold or copy: instructions, inserted customer details, conversation history, logs, caches, evaluation sets or fine-tuning data?
- What a yes opens up, in the guide's own terms
- Two views of the same copies. What a system prompt holds (instructions, secrets, personal data and business logic) and five routes its content leaves by: direct requests, quoted context, tool traces, logs and client-side bundles. Where data lives in the application (prompts and conversation history, retrieved documents, fine-tuning and training sources, logs, caches and evaluation sets) and five routes it comes back out by: citations, recall across users, training or fine-tuning text extracted from the model, a store someone else can read, and copies that survive deletion.
- Guide, address and the OWASP entry it names
- System Prompt Exposure, /web-security/system-prompt-exposure. Names LLM07:2025 System Prompt Leakage. LLM Data Leakage, /web-security/llm-data-leakage. Names LLM02:2025 Sensitive Information Disclosure, with LLM07:2025 and LLM08:2025 for the rows its neighbouring guides cover in depth.
- Test pack in the guide, counted
- System prompt: a text template, the prompt asset register and extraction fixtures, version 1.0, in five parts: 13 register entries for an invented equipment hire business's booking assistant, each classed and given one of three decisions (remove, move behind a server-side check, accept disclosure); four planted markers; extraction fixtures for the five routes; a record for each run; and rules for reading a result. Data leakage: a text template, the data-lineage worksheet and canary-record protocol, version 1, in five parts: eight columns, a worked example of 11 rows for an invented property management agency, a blank row to copy, a protocol of seven rules and six tests with a results sheet, and a short list for the places you could not account for.
- Have ready before the first run
- System prompt: one complete request captured from a test copy to the model provider, with everything in it listed; a test copy with synthetic customers wherever one exists; browser developer tools; stub destinations for tools that send data outside the business; and a production build for the bundle checks. Data leakage: a sitting with your developer, since the worksheet is meant to be finished in one; one real request followed from the browser to the model provider and back; every vendor the application pays or connects to, with each one's current data terms read and dated; and for the protocol, test accounts and synthetic canary records with an email address at a test domain and a test phone number you control.
- Evidence the guide tells you to keep
- System prompt: a record for each run, with the build (model and version, instructions version or hash, tool list, chat widget version and logging settings), the fixture and step, the identity used, the markers searched, where they were found, a result of leak observed, no leak observed or inconclusive, the register entry affected, and the action and owner; for each log store, who can read it and how long it keeps entries. Data leakage: one results line per test and marker, with when, by whom and through which account it was planted, the attempts and prompts, where and when it was found, the result and the row to fix. Results read as found, or not found in a stated number of attempts, and not as "not retained" or "not memorised", which the protocol says no test in it can show.
8. Planning and mapping. Do you need to plan a whole test of the application, or answer a customer or questionnaire that names the OWASP LLM Top 10?
- What a yes opens up, in the guide's own terms
- The ten 2025 risks in plain terms, which of them sit in your deployment and which with the model supplier, and how the LLM list differs from the web application Top 10. For planning: three pieces of work that share the name AI red teaming, and a plan for the one a business running a chatbot or agent owns, adversarial testing of its own application.
- Guide, address and the OWASP entry it names
- OWASP LLM Top 10, /web-security/owasp-llm-top-10. Covers all ten entries of the OWASP Top 10 for LLM Applications 2025, LLM01:2025 to LLM10:2025. AI Red Teaming, /web-security/ai-red-teaming. Names no category by number; its plan leaves a blank for each finding's 2025 category.
- Test pack in the guide, counted
- OWASP: a table, the owner crosswalk for the 2025 edition, 10 rows by 5 columns, one per category, giving an owner checklist, the evidence that shows it is in place, one harmless regression fixture, and the guide on this site or the kind of specialist who handles it. It states the edition and that its rows were reviewed on 14 November 2026. Red teaming: a text template, the AI application test plan, version 1, in eight parts, with a worked example for an invented rental agency's tenant assistant (seven threat hypotheses, eight registered cases and a benign control, with illustrative results), ending with an application test set beside a network red-team exercise for the same agency.
- Have ready before the first run
- OWASP: a test copy, synthetic records, test accounts and invented markers for the fixtures, and the edition and review date kept with any copy you make of the crosswalk. Red teaming: Parts 1 to 5 filled in and signed off by the application's owner before the first test message, including written authorisation, written permission from the owner of each other system the tests reach, the model provider's and platform's usage terms read and recorded, spending limits, test accounts, inboxes and numbers, and the stop conditions.
- Evidence the guide tells you to keep
- OWASP: the evidence column for each category, such as a tool register, server-side authorisation code or retrieval logs, and each fixture's result as violations out of runs, with errors and runs with missing logs counted as inconclusive. Red teaming: for each registered case, runs completed, violations and inconclusive runs; an evidence level from E1 to E5 with a CVSS v3.1 base score and vector and a business rating; a named reviewer's decision and what the result does not show; and a retest outcome of fixed, partially fixed, still reproducible or not retested.
About this library
AI application security: what the twelve LLM security guides cover
In this library, AI application security means the parts of an AI feature that a business builds and runs: the instructions it writes, the documents and messages the model is handed to read, the tools it can call, the places its replies are shown or sent, the data it keeps along the way and the usage it pays for.
Ten of the twelve guides indexed here each take one of those parts and go deep on it; the OWASP LLM Top 10 guide maps all of them to OWASP's 2025 list, and the AI red teaming guide plans a test that ties them together.
Red teaming a foundation model, and the model provider's own platform, sit outside them. The AI red teaming guide separates three pieces of work that share that name, testing a foundation model, a red-team exercise against a whole organisation and adversarial testing of an AI application, and the guides on this page are written for the third.
Each guide carries a working asset: a regression set, a fixture corpus, a test pack, a test matrix, a permission worksheet, a scenario map, a prompt register, an output test suite, a data-lineage worksheet, a token-budget model, a crosswalk and a test plan. Eleven of the twelve are built around an invented business, product or system and say so on their pages.
The twelfth, the OWASP guide's crosswalk, is arranged by risk category instead. The guides build their tests from harmless markers, synthetic or invented records and test accounts, in place of real customers' data.
Run them only on an application your business owns, or one whose owner has authorised the test in writing. The cost abuse scenarios go further: they are written only for a business testing its own application. The agentic AI security fixtures need the agent owner's written approval even when the owner is your own business.
How the selector is laid out, and why the rows run in this order
The selector is one table with a row for each question about your application.
Answer each question from what the application does today, not from what its design document says. A yes points to the guides named in that row. A no lets you set aside a guide that only that row points to. Each of the twelve guides is described in full in exactly one row.
The rows follow one request through an application. Text arrives from the person typing (row 1) and from content the model is handed to read (row 2). The model then calls tools (row 3), and an agent strings those calls into several steps with memory, other agents and approvals (row 4).
Its reply lands somewhere (row 5), and the whole request is paid for (row 6). The last two rows sit around every request rather than at one point in it: what the application holds and copies as it works (row 7), and how to plan a test or answer a question that names the OWASP list (row 8).
The second column says what a yes opens up, in the terms the guide itself uses. The third gives each guide's address, because the table cannot hold links, with the OWASP entry the guide names, written as the guide writes it; where a guide names none by number, the cell says so.
The fourth describes the guide's asset as published: what kind of thing it is, its parts and its size, counted from the page. The fifth comes from the guide's own preparation steps, and the sixth is the evidence the guide tells you to keep. Reasoning and sources stay on each guide, and all twelve are linked under Pages in this section.
Four kinds of AI application, and the order to read the guides in
An application can answer yes to several rows at once.
The four shapes below are the kinds of application the guides' own worked examples describe. The reading order for each is this page's suggestion, built from where each guide says its neighbours take over.
A chatbot that answers from your company's documents
Rows 1, 2 and 7 apply. Start with RAG security, because its pack needs a retrieval trace that shows which document IDs each search handed to the model, and the guide says that if your pipeline cannot yet show them, adding that trace comes before anything else, because filtering cannot be confirmed without it.
Then read prompt injection for what customers type, and indirect prompt injection for instructions planted in the documents themselves; the RAG guide hands that attack to the indirect guide and stays with who may retrieve what.
Finish with system prompt exposure and LLM data leakage, which follow the bot's instructions and the copies the application keeps in logs, caches, conversation history and evaluation sets.
An agent that calls tools or works through several steps
Rows 3 and 4 apply, and so does row 2, because the indirect guide counts tool results among the content a bot reads. Begin with AI tool permissions, which takes one tool at a time and asks which layer refuses a wrong call. Each of its fixtures runs twice: first against the tool server directly, the run the guide says tells you about the permission, then through a test copy of the agent, which tells you about the model.
If the tools reach the agent through the Model Context Protocol, the MCP server security guide adds what is particular to servers and clients.
Then read agentic AI security for the multi-step view: the goal, the plan, memory, messages between agents, the handoff to a person and when the agent stops. Each of these three guides names the other two as the place for what it leaves out.
A model whose output is shown, sent or run
Row 5 applies to any reply that is rendered as Markdown or HTML, in the chat window or anywhere else, or that reaches a staff screen, an email, a link, a structured action or a database query. Read LLM output handling first.
Its suite feeds synthetic outputs straight into each receiving system, through a stub or a recorded response, so whether a staff screen encodes a string does not depend on whether the model chose to write it.
Then read the two prompt injection guides, which cover how someone shapes the output in the first place; the output handling guide names the prompt injection guide for that input side and keeps to what the receiving systems do.
A feature billed for each request
Row 6 applies whenever the model is paid for per token, or a tool charges per call. The LLM cost abuse guide covers quotas, budgets, concurrency, alerts and the kill switch, and each of its five scenarios uses a handful of requests in a test environment with a low spending limit set before the first one.
It leaves step caps and stop conditions inside a multi-step agent to the agentic AI security guide. An agent that runs up model or tool charges is therefore a case for reading both.
Which OWASP entries the guides name, and why the edition matters
Eight guides each say which category of the OWASP Top 10 for LLM Applications 2025 covers their subject: LLM01:2025 Prompt Injection for both prompt injection guides, LLM02:2025 Sensitive Information Disclosure for LLM data leakage, LLM05:2025 Improper Output Handling for LLM output handling, LLM06:2025 Excessive Agency for AI tool permissions, LLM07:2025 System Prompt Leakage for system prompt exposure, LLM08:2025 Vector and Embedding Weaknesses for RAG security and LLM10:2025 Unbounded Consumption for LLM cost abuse. The OWASP LLM Top 10 guide covers all ten 2025 entries.
Three guides work differently. The MCP server security guide names no LLM category by number; it follows the 2026-07-28 revision of the Model Context Protocol specification and quotes each requirement with the force the specification gives it. The agentic AI security guide works from a separate OWASP list, the Top 10 for Agentic Applications for 2026, published on 9 December 2025.
The AI red teaming guide names no category by number, and its plan leaves a blank for each finding's 2025 category.
A category number belongs to one edition. The output handling guide notes that its risk was LLM02: Insecure Output Handling in OWASP's 2023/24 list, and LLM02:2025 is Sensitive Information Disclosure, the subject of the data leakage guide. The OWASP LLM Top 10 guide maps the 2025 edition and records that OWASP has published a 2026 edition, whose resource page, dated 3 August 2026, describes updated rankings; its crosswalk does not map that edition.
Before you compare numbers between a report, a questionnaire and these guides, check that all three mean the same edition.
The same guide keeps the LLM list apart from the OWASP Top 10:2025 for web applications, numbered A01:2025 to A10:2025, and says to label a finding by its cause, so one finding can carry both when the model is the route in and an ordinary control is what failed.
It also names the gaps: no guide on this site covers model supply chains under LLM03:2025 Supply Chain, whose package side it sends to the OWASP Top 10 guide, nor LLM09:2025 Misinformation, nor the training and fine-tuning side of LLM04:2025 Data and Model Poisoning, and it names the kind of specialist for each. Documents added to a knowledge base, the other side of LLM04:2025, it sends to RAG security.
What sits outside these guides
The OWASP LLM Top 10 guide sorts the 2025 risks by who can change the outcome.
It treats seven as decided mostly by your deployment, LLM01 among them for what an injected instruction can reach, two as shared with the model supplier, and misinformation as shared and mainly a quality question. The guides indexed here go deep on the first group.
The AI red teaming guide draws the other edge. It says the model maker controls a foundation model's training, weights and built-in safety systems, so that is where findings about the model can be fixed. In its terms, a red-team exercise against an organisation targets its network, accounts, devices and, where the exercise's consent covers them, its people and premises, and is judged on what it reaches across the organisation.
The guide's test plan lists both among its exclusions, each with where that work belongs, along with load, denial-of-service and volumetric testing.
Clever Ops works on the same side of that line. Its AI chatbot and agent security test is a test of your chatbot or agent, not of the AI model behind it, and it does not include red teaming of the underlying model or the AI provider's own platform.
Internal networks, staff devices, red teaming, phishing and physical testing need a network or red team specialist, and denial-of-service, load or volumetric testing is not part of any Clever Ops service.
Where a tender, panel or contract requires a CREST-accredited provider, Clever Ops is not CREST accredited, so we refer that work to a provider that is.
Where the service pages take over
Three of the guides draw the same line between their assets and a security test.
A regression set or a fixture suite lets your own team repeat the checks it knows about after each change; a security test asks what else the application can be pushed into, including through the paths nobody listed.
The Clever Ops AI chatbot and agent security test covers direct and indirect prompt injection, poisoned content in the documents a bot retrieves, actions it can be talked into taking, data it can be made to reveal and usage that runs up the AI bill.
Every tool, integration or MCP server the agent can call is in scope, because that is where a manipulated answer becomes a real action. Test before the bot gets access to customer data or the ability to act, and again when you add tools.
If Clever Ops built or hosts the bot, the work is a security review rather than an independent test, and the report states who built and who hosts it.
Two other services meet these guides at their edges. Where an AI assistant sits inside a larger custom application, the web application and API penetration test leaves the assistant to the AI chatbot and agent security test, because prompt injection and the actions the assistant can take need their own test cases.
Where the AI is in how an app was made rather than in what it does, such as an app built with Lovable, Bolt or a similar AI builder, the vibe-coded app security check concentrates on data exposure, authentication, secrets, payments and abuse.
The vibe coding security guide carries a thirty-item pre-launch checklist for those apps, which needs a browser, two test accounts and your platform's dashboard.
Frequently asked questions
The parts of an AI feature a business builds and runs: its instructions, what the model is handed to read, the tools it can call, where its replies go, what the application stores and the usage it pays for. Ten of the twelve guides each take one of those parts and carry an asset to run against your own application. The OWASP LLM Top 10 guide maps the parts to OWASP's 2025 list, and the AI red teaming guide plans one test across them. The OWASP LLM Top 10 guide says the model's training and the platform's own infrastructure sit with the provider, and treats supply chain and data and model poisoning as shared with the supplier.
The guide in the first row of the selector your application answers yes to, then the reading order for the kind of application closest to yours. If a customer or questionnaire has asked about the OWASP LLM Top 10, start with that guide's crosswalk: for each 2025 category it gives an owner checklist, the evidence that shows each item is in place, one harmless regression fixture and the guide that goes deeper, or the kind of specialist who handles it where no guide on this site does.
Three assets serve that purpose at different levels. The agentic AI security guide's scenario map takes a multi-step workflow one step per row, with a fixture, the safe behaviour to expect and an evidence log of actions attempted, approved, blocked and rolled back. The AI tool permissions worksheet compares read, write and delete variants of one tool and ends in nine denied-action fixtures. For one row per risk, the OWASP crosswalk has an owner checklist for each 2025 category, and its LLM06:2025 Excessive Agency row points to the tool permissions, agentic and MCP guides.
On your own, it means running the test packs in the selector against a test copy of your bot, with harmless markers, synthetic records and logs that show what each tool call did, and reading each result as a count over several runs. As a service, the Clever Ops AI chatbot and agent security test examines your chatbot or agent and every tool, integration or MCP server it can call. It does not test the AI model behind it.
Not without its owner's written authorisation. Use them only on an application your business owns, or one whose owner has authorised the test in writing. Read the model provider's and any platform's terms before you start, as the prompt injection and AI red teaming guides advise, and keep to test copies, test accounts and synthetic records. The cost abuse scenarios are written only for a business testing its own application.
The prompt injection guide, citing OWASP's prompt injection prevention cheat sheet, notes that model outputs can vary, so the same message can get a different reply on the next run. A result such as 0 of 10 describes those runs on that build. The OWASP LLM Top 10 guide treats a pass as a baseline for spotting regressions rather than proof that a category is absent, and the AI red teaming guide reads ten refusals in ten runs the same way.
Scope the right test for your application
Tell us what you have built, who uses it and when it needs to launch. You will get a plain-English recommendation: a website audit, a web application test or a referral to a specialist.