AI Agent Security Checklist: 12 Controls for Agentic AI

A vendor-neutral AI agent security checklist for security and platform owners. It gives 12 runtime controls, mapped to OWASP and NIST, with a test for each one and where it stops working.

Blog17 min read

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 riskWhat it looks likeChecklist controls
ASI01 Agent Goal HijackInstructions hidden in content the agent reads redirect what it is trying to do4, 3, 7
ASI02 Tool MisuseThe agent uses tools it legitimately holds in harmful ways3, 7
ASI03 Identity & Privilege AbuseThe agent borrows, inherits, or accumulates privileges. Logs attribute its actions to someone else.1, 2, 3
ASI04 Agentic Supply Chain VulnerabilitiesA compromised tool, plugin, MCP server, package, or model10
ASI05 Unexpected Code ExecutionModel-generated code runs where it can reach the host5
ASI06 Memory & Context PoisoningSomeone corrupts stored memory or retrieved context to steer later actions9
ASI07 Insecure Inter-Agent CommunicationMessages between agents are spoofed, altered, or unlogged8
ASI08 Cascading FailuresOne agent's fault spreads through connected agents and systems8, 12
ASI09 Human-Agent Trust ExploitationPersuasive output gets a person to approve something unsafe7
ASI10 Rogue AgentsA compromised or drifting agent keeps operating1, 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.

ControlRed flagMaps to
1. Inventory every agent and name an ownerNo register, or a register of approved tools onlyASI03, ASI10, NIST AI RMF Govern
2. Give each agent its own identityAgent runs under a human login or a shared service accountASI03, LLM06
3. Enforce least privilege and least agencyBroad tool access with restrictions enforced by the promptASI02, ASI03, LLM06
4. Treat every input as untrusted, and assume injection will succeedSecurity depends on the model ignoring malicious instructionsASI01, LLM01
5. Sandbox any code the agent can runModel output executed as code on a shared hostASI05, LLM05
6. Hold the deployment boundary and control egressCannot say where prompts and context goLLM02, ASI01 (exfiltration)
7. Require human approval for high-impact actions, and design against rubber-stampingApproval on everything, or approval on nothingASI09, ASI02
8. Constrain delegation and log agent-to-agent messagesAgents share credentials or message each other off the recordASI07, ASI08
9. Protect memory and retrieved contextShared memory across users with no validation or expiryASI06, LLM04, LLM08
10. Vet the agentic supply chainAgents can install or connect new tools at runtimeASI04, LLM03
11. Log every action to an attributable, exportable audit trailA dashboard assembled after the fact instead of a runtime logASI10, ASI03, NIST AI RMF Measure
12. Keep a working kill switch and an agent incident runbookStopping an agent means filing a ticket with the vendorASI10, 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

Common questions.

What is AI agent security?

AI agent security is the practice of protecting autonomous AI systems that plan, call tools, and act on your systems with delegated access. It covers the agent's identity, what it may touch, what it ingests, and what code it can run. It also covers which actions need human approval, and how you log and stop every action. It assumes that someone will sometimes manipulate the model, and it limits what that can cost.

What are the biggest security risks of AI agents?

The OWASP Top 10 for Agentic Applications for 2026 lists them: agent goal hijack, tool misuse, identity and privilege abuse, and agentic supply chain vulnerabilities. The list continues with unexpected code execution, memory and context poisoning, insecure inter-agent communication, cascading failures, human-agent trust exploitation, and rogue agents. Most trace to one root: a system with real access that acts on input it cannot fully trust.

Can prompt injection be prevented?

Not reliably today. In NIST research on agent hijacking, new red-team attacks raised the success rate from 11% for the strongest baseline attack to 81%. Input screening and injection detection lower the rate, but they do not reach zero. The practical defense is architectural. Make sure that a successful injection can only select among permitted, logged actions, with human approval on the high-impact ones.

How is agentic AI security different from LLM security?

LLM security is mostly about what a model says: leaked data, harmful or false output, and prompt injection that changes a response. Agentic AI security is about what a system does. A model can hold credentials, call tools, keep memory, and delegate to other agents. Then the risks become privilege abuse, code execution, poisoned memory, and actions at machine speed. That is why OWASP publishes a separate agentic list.

Do AI agents need their own identities?

Yes. An agent that runs under a human's login or a shared service account breaks separation of duties. Your audit log then attributes its actions to someone else. Give each agent its own credentials and permission scopes in the identity provider that you already run. Then every action is attributable, and you can revoke access for one agent without touching anyone else.

Read next.

Start in one shop.

Two Bob units

Head mount, chest mount, or one of each.

The decryption computer

It decrypts each recording into your own cloud.

Swarm

Installed in your own environment.

Start with Record. Add Live and Co-Engineer when your team asks for them.

Get a demo