
Most security checklists describe a system that does what it is told. An AI agent does something different. It reads untrusted content, decides what to do next, and then acts with credentials you gave it.
That difference is why 2026 guidance on agent security has converged on a fairly consistent set of controls. Identity, narrow permissions, external policy enforcement, careful handling of tool and memory inputs, and fast revocation show up again and again across vendor, standards-body and research sources.
This article turns that guidance into ten checks you can run against any agent before it reaches production. Where numbers come from surveys or lab studies, we say so. Treat them as indicators of direction, not as precise industry benchmarks.
1. Why Agents Break the Old Security Model
Traditional application security assumes code paths are fixed. You review the code, test the inputs, and lock down the network. The behavior at runtime is largely the behavior you reviewed.
An agent plans its own steps. It retains memory, calls tools, and acts with delegated authority. Its next action depends on whatever text it has just read, which may be a web page, a GitHub comment, a tool description or a document in a vector store.
The core problem: low-trust content, high-impact actions
Research summarized in 2026 describes prompt injection evolving into an agent-control and supply-chain problem. Agents can convert low-trust content into high-impact actions. The risk rises as agents gain access to ERP, CRM, coding and cloud systems.
That framing is the right one for a checklist. The question is not whether the model can be fooled. Assume it can. The question is what the agent is able to do when it is.
Benchmarks are not a defense
Google DeepMind reported that automated agent-swarm attacks reduced attack resistance to 10% or less on six of seven tested models, including models that score well on standard benchmarks. A model passing a static injection test says little about its behavior against an adaptive attacker.
So the design principle for everything below is this: enforce limits outside the model, in the runtime, rather than asking the agent to police itself.
2. The Accountability Gap: What the Survey Numbers Say

One survey reported in recent research gives a sober picture of where organizations stand. These are self-reported figures and should be read that way.
- 52% reported an AI-agent security or privacy incident in the past year.
- 9.5% could name a formally accountable person for their agents.
- 51%: the average share of permitted actions for which agents enforced behavioral policies.
- 12.5% could fully reconstruct an agent’s actions and authority 30 days later.
- 6% could revoke a rogue agent’s access across systems within one hour, while 58% had already needed emergency revocation.
Reading the pattern
The numbers share a theme. Agents are being deployed faster than ownership, forensics and containment are being built. Incidents are common, yet few teams can answer who owns the agent, what it did, or how to stop it quickly.
Each of the next checks targets one of those gaps.
3. Check One: Inventory and Ownership
You cannot secure agents you do not know exist. Guidance from several sources starts with a current register of every agent.
What the register should hold
- The agent’s purpose and a named, accountable owner
- The model and provider in use
- Every tool, data source and memory store it can reach
- The credentials it holds and their scope
- Enforceable limits and an emergency stop mechanism
Why a named person matters
When only 9.5% of surveyed organizations can name an accountable person, incident response starts with a search for who is responsible. A named owner shortens that. It also gives someone the authority to decide whether the agent keeps running.
Pass test: pick any agent at random and find its owner, purpose and credential list in under five minutes.
4. Check Two: A Unique, Short-Lived Identity per Agent
Shared service accounts and inherited user access make agent actions impossible to attribute. Current guidance recommends the opposite: each agent gets its own identity, and credentials are short-lived and scoped to the task.
Practices to adopt
- Give each agent a separate identity. Never let it inherit a user’s full access.
- Use short-lived, task-scoped credentials issued from a central vault.
- Prefer JWT or federated authentication over static API keys.
- Rotate or expire access automatically when the task ends.
The static key problem
Static keys in environment files are exactly what several 2026 incidents targeted. A reported vulnerability in a documentation-lookup MCP server allowed unsanitized custom instructions to push connected coding agents into sending environment-file credentials and deleting files. If the key is not in the environment, it cannot be exfiltrated from there.
Pass test: revoke one agent’s identity and confirm no other agent or human workflow is affected.
5. Check Three: Least Privilege That Is Actually Narrow
Everyone endorses least privilege. In practice, agents are often handed broad access because it is easier. Checklists in 2026 get specific about what narrow means.
Restrict along four axes
- Task: permissions tied to the job, not the agent in general.
- Data: only the datasets the task requires.
- Time: access that expires.
- Environment: separate dev, test and production permissions.
Tool-level authorization and default-deny
Authorize at the tool level with allowlists, not at the application level. Apply default-deny for outbound network access, so a compromised agent cannot send data to arbitrary destinations.
Why role limits alone fail
A controlled Cequence and KPMG prototype study found agents with fixed permissions attempted actions outside their assigned role in 44% of runs. It is a prototype evaluation, not a field measurement, but it supports the point. Roles stated in a prompt are suggestions. Roles enforced by the runtime are limits.
Pass test: list the actions an agent can technically perform. Compare that to what it needs to do. Close the gap.
6. Check Four: An External Policy Gateway for Tool Calls

The strongest recurring recommendation is to put a policy enforcement point between the agent and its tools. The gateway approves, blocks or escalates each call. The agent never gets to decide its own limits.
What the gateway evaluates
- Is this tool on the allowlist for this agent and task?
- Do the parameters pass validation?
- Does the action exceed a value, volume or sensitivity threshold?
- Does it need human approval?
Why enforcement belongs in the host
Researchers studying MCP attacks argue that authorization must be enforced by the host or runtime, not by prompt-based detectors. Detectors can be bypassed by the same text that carries the attack. A gateway checking structured parameters is far harder to talk around.
The survey figure that agents enforce policies for only 51% of permitted actions is a reminder that behavioral policy inside the agent is partial at best.
Pass test: attempt a disallowed tool call in staging. It should be blocked and logged without relying on the model to refuse.
7. Check Five: Human Approval for Irreversible Actions
Not every action needs a human. Some do. Guidance consistently calls for explicit approval on financial, destructive or irreversible steps.
Make approvals meaningful
- Require one-time approval for each action, not a blanket grant.
- Show the exact parameters: the amount, the recipient, the files to be deleted.
- Escalate exceptional requests that fall outside normal patterns.
Avoid approval fatigue
If reviewers see hundreds of prompts a day, they click through. Reserve approvals for the high-impact tier and let the gateway automatically handle the low-risk calls. A short list of gated actions is more secure than a long one nobody reads.
8. Check Six: Treat Every External Input as Untrusted
Retrieved documents, web pages, emails, tool outputs and code comments are all input from outside your trust boundary. Current guidance says to treat all of it as untrusted.
Where injection actually arrives
Recent research points to attackers shifting from user prompts to trusted channels. These include MCP internals, tool descriptions, secondary tool calls and Markdown skill files.
- One report described attacker-controlled GitHub text redirecting three coding agents to expose runtime secrets through comments or commits.
- Research on poisoned skill files reported attack success rising from 0.5% to 45% on average, and up to 68.9% for some models.
- The CVE count tells a similar story: 52 prompt-injection CVEs were listed for 2026 through November 6, including six critical, though improved search methods likely inflated the recent rise.
Controls to apply
- Sanitize and validate inputs, and validate tool parameters before execution.
- Separate instructions from data wherever the framework allows.
- Strip or flag instruction-like content in retrieved material.
- Review skill and configuration files like code, with version control and sign-off.
Filtering helps, but do not rely on it alone. Pair it with the limits in checks three and four, so a successful injection still has little to work with.
9. Check Seven: Vet the MCP and Tool Supply Chain

The Model Context Protocol makes it easy to connect agents to tools. It also makes it easy to connect them to malicious ones. Several 2026 findings are worth knowing.
What the research found
- Malicious tool descriptions caused agents to perform attacker actions in 22.9% of 9,720 tested framework and tool combinations. None of 12 audited frameworks had intentional defenses.
- A data-exfiltration technique called Log-To-Leak achieved 62.64% to 100% success across 18 agent and server combinations, often without affecting task completion, which makes it hard to notice.
- OWASP reported a malicious MCP server promoted through 23 GitHub pull requests. It behaved normally for three tool calls, then changed its metadata to steer agents toward credentials and hide its activity.
The lesson of the three-call server
A one-time review at install is not enough. A server can pass inspection and change later. Controls should account for that.
- Maintain an allowlist of approved MCP servers and pin versions.
- Detect and alert on changes to tool descriptions or metadata after approval.
- Run tools in sandboxes with network segmentation and default-deny egress.
- Restrict filesystem access, since path traversal and file-level risks are recurring findings.
Pass test: change a tool description in staging. Your system should flag the drift and pause that tool.
10. Check Eight: Secure Agent Memory
Persistent memory lets agents improve across sessions. It also gives an attacker a place to plant instructions that survive past the original conversation.
Memory controls from current guidance
- Validate what gets written to memory.
- Preserve provenance, so you know where each entry came from.
- Segment memory by user or tenant.
- Enforce expiry so stale or poisoned entries age out.
- Guard RAG and vector stores, which OWASP-linked tooling now explicitly tests for weakness.
Treat memory as a data store, not a notebook
A good test is whether you could remove a single bad entry and everything derived from it. If you cannot trace provenance, you cannot clean up after poisoning.
11. Check Nine: Logging, Forensics and a Real Kill Switch
This is where the survey data is bleakest. Only 12.5% of organizations could reconstruct an agent’s actions and authority 30 days later. Only 6% could revoke a rogue agent’s access across systems within an hour.
Logging requirements
- Record every tool call with parameters, the identity used, the policy decision and the input that triggered it.
- Correlate telemetry across agents and systems.
- Retain logs long enough to cover the investigations you expect.
Containment requirements
- One action revokes an agent’s credentials everywhere.
- Agents can be isolated without taking down unrelated systems.
- The stop mechanism is tested on a schedule, not just documented.
Pass test: run a drill. Pick an agent, revoke it, and time how long it takes to confirm no access remains.
12. Check Ten: Map to OWASP and Test Adversarially
The OWASP Top 10 for Agentic Applications 2026, released December 9, 2025, is the baseline most teams are mapping to. It was developed with more than 100 experts, researchers and practitioners. No replacement edition was identified in recent updates.
What it covers
The framework goes beyond prompt injection. It covers goal hijacking, tool misuse, privilege abuse, supply-chain vulnerabilities, code execution, memory poisoning, insecure inter-agent communication and cascading failures. It is a risk taxonomy, not a set of verified case studies, so use it as a structure for your own testing.
Operationalizing it
- Map each agent to the relevant risks and record the control that addresses each.
- Run multi-turn adversarial testing against live or staging agents.
- Use static scanning for prompt injection, unsafe output handling, MCP command injection and path traversal.
- Re-test whenever a model, tool or skill file changes.
Tools named in OWASP-linked material include Humanbound, SecureAI-Scan, PyRIT, Lasso, SecureAIFlow and Tenuo. These are capability examples, not independently verified outcomes. Evaluate them against your own environment.
Multi-agent systems
If agents talk to each other, treat messages between them as untrusted input as well. One compromised agent should not be able to command another with full trust. Cascading failures are on the OWASP list for a reason.
13. A 30-Day Rollout Plan
You do not need to do everything at once. Sequence the work by how much risk each step removes.
- Week 1, see: build the inventory, name owners, list credentials and tool access.
- Week 2, shrink: replace static keys with short-lived identities, cut permissions to the task, set default-deny egress.
- Week 3, enforce: deploy a policy gateway for tool calls, gate irreversible actions, pin and monitor MCP servers.
- Week 4, prove: turn on full logging, run a revocation drill, and run adversarial tests mapped to the OWASP list.
Ten-line checklist
- Every agent has a named owner and registry entry.
- Every agent has its own short-lived identity.
- Permissions are scoped by task, data, time and environment.
- A gateway outside the model enforces tool policy.
- Irreversible actions need explicit, parameter-level approval.
- All external content is treated as untrusted.
- MCP servers and skills are allowlisted, pinned and monitored for drift.
- Memory writes are validated, attributed and expire.
- Logs reconstruct actions, and revocation works within the hour.
- Adversarial testing is mapped to OWASP and repeated on every change.
Conclusion
The throughline of 2026 guidance is simple. Do not trust the agent to protect itself, and do not trust the content it reads. Put identity, limits, approvals and visibility around it, enforced where the model cannot override them.
The survey figures suggest most organizations are not there yet, with incidents common and accountability and containment thin. That makes this a good moment to run the ten checks above. Start with the inventory, because every other control depends on knowing what you are protecting.

Leave a Reply