This checklist gives the security or platform owner who must sign off on agentic AI a set of 12 controls. Each control maps to the OWASP and NIST sources that your auditors will recognize. Each one comes with a test you can run, and each one says plainly where it stops working. The checklist is vendor-neutral. Use it on any platform, including ours.
Here is why it matters. In January 2025, NIST researchers published a study of AI agent hijacking: attacks that hide instructions in the data an agent reads. The strongest known attack worked 11% of the time. After red-teaming, the strongest new attack worked 81% of the time.
That gap is the whole subject of AI agent security. Someone can trick a model that only writes text into saying something wrong. Someone can trick a system that holds credentials, calls tools, and changes records into doing something wrong. It happens at machine speed, under an identity that your logs trust. A fix inside the model will not hold. You bound the risk with architecture.
What is AI agent security?
AI agent security is the practice of protecting autonomous AI systems that plan, call tools, and act with delegated access. It governs who the agent is, what it can reach, what it ingests, and what code it runs. It also governs which actions need a human, and how you log and stop every action.
It overlaps with application security and model security without being either. Application security protects code that does what it was written to do. Model security protects what a model outputs. Agent security has to assume that the system will sometimes decide to do the wrong thing, because someone persuaded it to. It limits what that decision can cost. If you want the category definition first, start with what agentic AI is.
Why agentic AI security is a different problem
The standards bodies already drew the line. The OWASP Top 10 for LLM Applications 2025 puts prompt injection first (LLM01). It also names Excessive Agency (LLM06): an LLM-based system with more permission or autonomy than its task needs. In December 2025, OWASP published a separate Top 10 for Agentic Applications for 2026. The reason: the threats change once a model can plan, remember, and act across other systems.
Government guidance followed within months:
- NIST's Center for AI Standards and Innovation (CAISI) issued a request for information on securing AI agent systems in January 2026. It names indirect prompt injection, poisoned models, and misaligned objectives. It asks specifically for methods to constrain and monitor an agent's access in its deployment environment.
- NIST launched the AI Agent Standards Initiative on February 17, 2026. AI agent security and identity is one of its three pillars.
- On May 1, 2026, CISA, the Australian Signals Directorate's Australian Cyber Security Centre, and other US and international partners released joint guidance: Careful Adoption of Agentic AI Services.
Your program-level baseline remains. The NIST AI Risk Management Framework (Govern, Map, Measure, Manage) is still the right structure for ownership and risk decisions. So is its Generative AI Profile, NIST AI 600-1. Both came before the agent-specific guidance, though. Neither tells you how to stop a running system from deleting a table. That is a runtime question, so every control below is a runtime control. Our AI governance framework for agentic systems covers the policy side.
One more finding should set your expectations. Gray Swan ran a large red-teaming competition with CAISI and the UK AI Security Institute. More than 400 participants made over 250,000 attack attempts against 13 frontier models in agentic scenarios. At least one attack succeeded against every model. Plan for a manipulated model. Put your controls where manipulation stops mattering.
The agentic AI threat map
Start from the threats, so every control has a reason to exist. The risk names below are OWASP's, from the OWASP Top 10 for Agentic Applications. The one-line summaries and the control mapping are ours.
| OWASP agentic risk | What it looks like | Checklist controls |
|---|---|---|
| ASI01 Agent Goal Hijack | Instructions hidden in content the agent reads redirect what it is trying to do | 4, 3, 7 |
| ASI02 Tool Misuse | The agent uses tools it legitimately holds in harmful ways | 3, 7 |
| ASI03 Identity & Privilege Abuse | The agent borrows, inherits, or accumulates privileges. Logs attribute its actions to someone else. | 1, 2, 3 |
| ASI04 Agentic Supply Chain Vulnerabilities | A compromised tool, plugin, MCP server, package, or model | 10 |
| ASI05 Unexpected Code Execution | Model-generated code runs where it can reach the host | 5 |
| ASI06 Memory & Context Poisoning | Someone corrupts stored memory or retrieved context to steer later actions | 9 |
| ASI07 Insecure Inter-Agent Communication | Messages between agents are spoofed, altered, or unlogged | 8 |
| ASI08 Cascading Failures | One agent's fault spreads through connected agents and systems | 8, 12 |
| ASI09 Human-Agent Trust Exploitation | Persuasive output gets a person to approve something unsafe | 7 |
| ASI10 Rogue Agents | A compromised or drifting agent keeps operating | 1, 11, 12 |
Two patterns run through the list. Most of these risks need the agent to hold real access. So when you shrink and attribute that access (controls 1 to 3), you reduce almost all of them. The rest need the agent to act on something it cannot fully trust. So design for the attack that gets through. Do not hope that it will fail.
The AI agent security checklist: 12 controls
Here are twelve controls, ordered roughly from foundation to response. Each one says what to require, how to test it, and where it stops working. The tests matter most. A control that you did not test is a control that you assume.
1. Inventory every agent and name an owner
Require: a register of every AI agent in your environment, including the ones nobody approved. Each entry has a named human owner, a written purpose, and a list of the systems and data the agent can reach. Test: look for API keys and OAuth grants issued to AI tools. Look for agent frameworks on developer and analyst machines. Then compare what you find against the register. Where it stops: an inventory tells you what exists. It does not tell you what each agent does. But every other control on this list applies only to agents you know about. An agent that is not on the register has none of them.
2. Give each agent its own identity
Require: each agent authenticates as itself, with its own credentials and permission scopes. You manage them in the identity provider that you already run. No shared service accounts. No borrowed human logins. Why: when an agent acts under a person's credentials, your audit log records the person. Attribution is wrong by construction, and separation of duties is gone before the agent does anything. OWASP lists this as Identity and Privilege Abuse (ASI03). NIST made agent identity and authorization one of the research areas of its AI Agent Standards Initiative, launched in February 2026.
Test: pick one action that an agent took last week and find it in your logs. Does the entry name the agent, or a human? Then revoke the agent's credential and confirm that it stops working. Where it stops: identity makes actions attributable. It does not limit them. Identity for agents is a subject of its own. Our guide to identity and access for AI agents covers it.
3. Enforce least privilege and least agency
Require: an explicit allowlist of the tools, actions, and resources that each agent may use. Scope it per tool: read or write, which records, which systems. Anything not on the list is unavailable. The OWASP AI Agent Security Cheat Sheet recommends allowlists over wildcards for exactly this reason. OWASP's agentic guidance adds a second principle, least agency. Limit how much the agent may decide on its own, in addition to what it can reach. The OWASP Top 10 for LLM Applications 2025 names the failure mode directly: Excessive Agency (LLM06).
Test: instruct the agent to use a tool that it should not have. Do it directly, and also through a planted document. The correct result is that the tool does not exist in its runtime. A polite refusal is a fail. Where it stops: an allowlist bounds a hijacked agent to what it is allowed to do. The agent can still misuse a tool that it legitimately holds. That is why the dangerous tools also need control 7.
4. Treat every input as untrusted, and assume injection will succeed
Prompt injection is the top risk on both OWASP lists: LLM01 for LLM applications, and Agent Goal Hijack (ASI01) for agentic ones. In agents, it usually arrives indirectly. Instructions hide in an email, a web page, a ticket, or a retrieved document that the agent reads while it does its job.
Require: treat everything that the agent ingests as untrusted data. That includes user messages, documents, emails, API responses, and tool outputs. Keep that data separate from instructions, and screen it for injection attempts, as the OWASP cheat sheet describes. Test: seed a test document with hidden instructions, such as an order to forward this file to an outside address, or to change this record. Run the agent over it in a staging environment.
Where it stops: this is the control to be most honest about. No filter reliably stops prompt injection today. NIST tested agent hijacking. New red-team attacks lifted the success rate from 11% for the strongest baseline attack to 81%. When attackers repeated an attack 25 times, the average success rate rose from 57% to 80%. Detection lowers the rate. It does not reach zero. So design for the injection that gets through. Its reach should end at the allowlist (control 3), the approval gate (control 7), and the audit log (control 11).
5. Sandbox any code the agent can run
Require: code that the model writes never executes directly on a host. It runs in an isolated runtime with an allowlist of packages and with system-level modules blocked. The runtime has memory and time limits, and no network access beyond approved endpoints. OWASP calls the failure Unexpected Code Execution (ASI05): the shortest path from a manipulated prompt to a compromised machine. Test: have the agent generate code that imports operating-system or subprocess modules. Also have it open an outbound connection, or read a file outside its scope. Confirm that the sandbox blocks and logs each attempt. Where it stops: a sandbox contains code. It does not judge whether permitted code does the right thing.
6. Hold the deployment boundary and control egress
Require: a written list of every place where the agent sends data. That covers prompts, retrieved context, tool outputs, and logs, and above all the inference provider. Block everything else, and screen outbound content for sensitive data. Some data falls under a regime such as ITAR, CMMC, or NERC CIP. For that data, agree with your compliance team whether it may leave your perimeter at all. Do this before you choose a deployment model, because that decision rules platforms in or out. This control addresses the OWASP risk Sensitive Information Disclosure (LLM02).
Test: capture network traffic from the agent's runtime during a real task. Every destination should be on the list that you wrote. Where it stops: egress control keeps data inside approved paths. It cannot stop an agent from misusing data along an approved path. And on-premises is not the same as air-gapped. If your program requires an air gap, make it a separate, explicit requirement.
7. Require human approval for high-impact actions, and design against rubber-stamping
Require: a named list of high-impact actions that wait for explicit human approval. Examples are payments, deletions, permission changes, messages to outside parties, and changes to operational systems. The reviewer sees a preview of exactly what will happen and has a way to interrupt or roll back. This is the human-in-the-loop control in the OWASP cheat sheet.
Test: measure it. Count approvals per reviewer per day and the time taken on each. If reviewers approve most requests within seconds, the control exists on paper only. Where it stops: OWASP added Human-Agent Trust Exploitation (ASI09) to its agentic list for a reason. A fluent, confident explanation can persuade a reviewer to approve something unsafe. Show the reviewer the raw action and its target, as well as the agent's summary. Keep the approval set small enough that each request gets real attention.
8. Constrain delegation and log agent-to-agent messages
Require: an agent can never give another agent permissions that it does not hold. Messages between agents are authenticated and logged. A fault in one agent cannot run unchecked through the rest. OWASP names the two failures Insecure Inter-Agent Communication (ASI07) and Cascading Failures (ASI08). Its cheat sheet recommends trust boundaries and circuit breakers between agents. Test: have a low-privilege agent ask a higher-privilege agent to do a restricted action for it. This is the confused-deputy test, and it should fail. Where it stops: logs of multi-agent conversations give you the record. Review of that record at volume needs tooling of its own.
9. Protect memory and retrieved context
Require: validate anything that an agent writes to long-term memory before it is stored. Isolate memory per user or tenant, let entries expire, and audit stored memory for sensitive data. The risk is Memory and Context Poisoning (ASI06). A false fact or a planted instruction stored today steers an action next month. Test: plant a false instruction in memory during one session. Then check whether it changes the agent's behavior in a different user's session. Where it stops: a retrieval index is memory too. A poisoned source document in your knowledge base needs content controls upstream of the agent.
10. Vet the agentic supply chain
Require: inventory and version-pin every tool, plugin, MCP server, package, and model that an agent uses. Review each one the way you review any third-party code. OWASP tracks this as Supply Chain (LLM03) and Agentic Supply Chain Vulnerabilities (ASI04). Its Agentic Security Initiative published a practical guide to secure MCP server development. Test: can you list the exact version of every tool server that your agents called last week, and who approved each one? Where it stops: a reviewed dependency can still ship a malicious update. Pinning and change review stop a silent swap.
11. Log every action to an attributable, exportable audit trail
Require: log every model call, tool call, file access, and message. Each entry records the agent's own identity, the input that triggered it, the data it touched, and the result. The log streams to your SIEM, with alerts for agent-specific patterns such as permission errors or sudden spikes in tool calls. Test: pick an agent action from last week. Answer four questions from the logs alone: what did it do, when, with what data, and why? If the answer requires a reconstruction, the log is incomplete. Where it stops: a log is evidence. It does not prevent anything. It converts an incident into an investigation that you can finish.
12. Keep a working kill switch and an agent incident runbook
Require: a named on-call role that can stop a running agent immediately, mid-task. That role revokes the agent's credentials and preserves its state for investigation. An incident runbook written for agents backs the role: containment, credential revocation, action review, and rollback. This control exists for Rogue Agents (ASI10): a compromised or drifting agent that keeps operating. Test: use the switch in a drill, mid-task, and time the gap between the decision and the stop. Where it stops: when you stop an agent, you do not undo what it already did. Know which of its actions are reversible before you need to reverse one.
The checklist at a glance
Take this table into architecture reviews and vendor calls. If an owner or a vendor cannot answer a row plainly, treat the row as failed until they can.
| Control | Red flag | Maps to |
|---|---|---|
| 1. Inventory every agent and name an owner | No register, or a register of approved tools only | ASI03, ASI10, NIST AI RMF Govern |
| 2. Give each agent its own identity | Agent runs under a human login or a shared service account | ASI03, LLM06 |
| 3. Enforce least privilege and least agency | Broad tool access with restrictions enforced by the prompt | ASI02, ASI03, LLM06 |
| 4. Treat every input as untrusted, and assume injection will succeed | Security depends on the model ignoring malicious instructions | ASI01, LLM01 |
| 5. Sandbox any code the agent can run | Model output executed as code on a shared host | ASI05, LLM05 |
| 6. Hold the deployment boundary and control egress | Cannot say where prompts and context go | LLM02, ASI01 (exfiltration) |
| 7. Require human approval for high-impact actions, and design against rubber-stamping | Approval on everything, or approval on nothing | ASI09, ASI02 |
| 8. Constrain delegation and log agent-to-agent messages | Agents share credentials or message each other off the record | ASI07, ASI08 |
| 9. Protect memory and retrieved context | Shared memory across users with no validation or expiry | ASI06, LLM04, LLM08 |
| 10. Vet the agentic supply chain | Agents can install or connect new tools at runtime | ASI04, LLM03 |
| 11. Log every action to an attributable, exportable audit trail | A dashboard assembled after the fact instead of a runtime log | ASI10, ASI03, NIST AI RMF Measure |
| 12. Keep a working kill switch and an agent incident runbook | Stopping an agent means filing a ticket with the vendor | ASI10, ASI08, NIST AI RMF Manage |
LLM IDs refer to the OWASP Top 10 for LLM Applications 2025. ASI IDs refer to the OWASP Top 10 for Agentic Applications for 2026. The NIST AI RMF function names show where each control sits in an existing risk program.
How to deploy agentic AI security controls
If you start all twelve controls at once, the checklist becomes a spreadsheet that nobody finishes. Sequence them.
- First, the three you need to evaluate anything: the inventory (1), per-agent identity (2), and the audit trail (11). Until you know what exists, who it is, and what it did, the other controls have nothing to attach to.
- Then shrink the blast radius: allowlists (3), the sandbox (5), and egress control (6). These controls still hold when prompt injection succeeds.
- Start agents on read-only, low-impact work, and widen permissions one tool at a time. Put the approval gate (7) on anything irreversible.
- Red-team before production and after every change to tools, prompts, or models. The OWASP cheat sheet recommends adversarial regression tests in CI/CD. CAISI's competition found that attacks which break well-defended models often transfer to weaker ones. So reuse what your red team finds.
- Drill the kill switch (12) before you need it. Include agents in your existing access reviews, change management, and incident response. Do not build a parallel process.
The same checklist applies whether you buy or build. Open-source agent frameworks are a legitimate path. But with them, most of these controls are yours to build and maintain, so count that work honestly. When you compare vendors, pair this list with our guide on how to evaluate AI agents for the enterprise.
A worked example: controls built into the runtime
Here is one example of these controls built into the runtime from the start. Mission Control builds synthetic workers, and Swarm is the platform they run on. For this checklist, the difference that matters is where the controls live. They live in the runtime around the model. They do not live in the model's instructions. Everything below comes from our published governed AI and platform pages. Verify it the way you would verify anyone else.
- Identity (2): every worker has a unique, verifiable identity, with its own credential sets and permission scopes. SSO and OIDC integrate with your existing identity provider.
- Least privilege (3): a capability whitelist. If a capability is not on a worker's activation list, it does not exist for that worker. The security model is: allow nothing, then enable specific things.
- Untrusted input (4): input sanitization and injection detection on inbound signals. The design assumption is stated plainly. When an attack succeeds, a prompt injection can only select a capability within the whitelist. It cannot execute arbitrary code.
- Sandboxed execution (5): no arbitrary code execution. A package whitelist applies, and the interpreter blocks os, subprocess, and sys.
- Deployment boundary (6): your own environment (Azure, AWS, Google Cloud, Docker, or Kubernetes), containerized, behind your firewall, with no callbacks to external servers. Inference is vendor-agnostic across Anthropic, OpenAI, or self-hosted models. Output redaction applies to outbound communications.
- Human approval (7): escalation triggers send high-risk decisions to human operators before execution.
- Delegation and scheduling (8): workers cannot grant permissions that they do not have. Swarm logs inter-worker and worker-to-human messages. Workers run only inside approved operating windows.
- Audit (11): Swarm logs every LLM call, action, and file access with full provenance.
- Kill switch (12): immediate termination of a worker's process, mid-operation.
The governed AI page lists nine of these controls as the nine real-time governance firewalls. They are identity, human RBAC, synthetic RBAC, execution sandbox, audit logging, delegation controls, scheduling, communications, and the capability whitelist. The platform page describes the other runtime controls: input sanitization, injection detection, escalation triggers, output redaction, and the kill switch.
Now the limits, because a vendor that oversells loses the security review. Our published pages make no specific claims about memory poisoning defenses (9). They also make none about review of the third-party tools and models that you connect (10). Ask us for specifics there, as you would ask any vendor. The firewalls bound what a worker can do and make every action attributable. They do not make its judgment inside those bounds correct. On-premises is not automatically air-gapped, so state an air-gap requirement explicitly. And deployment runs through a pilot with a forward-deployed engineering team, which is a heavier engagement than a tool install.
Start with five questions this quarter
AI agent security comes down to one design choice: stop relying on the model to behave, and make misbehavior cheap. Before you complete all 12 controls, get honest answers to these five questions about the agents that already run in your environment:
- Can we name every agent in our environment, with an owner?
- Does any agent act under a human's login or a shared service account?
- For our most privileged agent, what happens if a document it reads tells it to send our data somewhere?
- For any agent action last week, can we say what it did, with what data, and why, from logs alone?
- Who can stop a running agent, and did they do it in a drill?
Any question that you cannot answer is where your checklist starts. If you want to see these controls run inside your own perimeter, talk to our team.
References
- OWASP Gen AI Security Project, "OWASP Top 10 for Agentic Applications for 2026" (December 2025)
- OWASP Gen AI Security Project, "OWASP Top 10 for Agentic Applications: The Benchmark for Agentic Security in the Age of Autonomous AI"
- OWASP Gen AI Security Project, "OWASP Top 10 for LLM Applications 2025"
- OWASP Cheat Sheet Series, "AI Agent Security Cheat Sheet"
- OWASP Gen AI Security Project, Agentic Security Initiative
- NIST, "Technical Blog: Strengthening AI Agent Hijacking Evaluations" (January 2025)
- NIST CAISI, "Insights into AI Agent Security from a Large-Scale Red-Teaming Competition" (March 2026)
- NIST, "CAISI Issues Request for Information About Securing AI Agent Systems" (January 2026)
- NIST, "Announcing the AI Agent Standards Initiative for Interoperable and Secure Innovation" (February 2026)
- NIST, AI Risk Management Framework
- NIST AI 600-1, "Artificial Intelligence Risk Management Framework: Generative Artificial Intelligence Profile" (July 2024)
- CISA, "Careful Adoption of Agentic AI Services" (May 2026)
- Mission Control governance and platform detail: /governed-ai/, /platform/