Skip to content
Agentic Control Plane

OWASP Agentic Top 10: What a Control Plane Covers, Risk by Risk

David Crowe David Crowe · · 10 min read
standards compliance
Share X HN LinkedIn

A compromised MCP server called postmark-mcp silently BCC’d every outgoing email to an attacker’s address. It ran for weeks before anyone noticed. Trend Micro later reported 492 exposed MCP servers with no authentication.

In December 2025 OWASP published the Top 10 for Agentic Applications, reviewed by more than 100 researchers. This post goes through the ten risks and says what a control plane does about each one. A control plane here means a layer on the tool-call path that checks each call before it runs and logs it. It does not mean the model or the framework.

Some risks it covers well. Some it barely touches. I’ll say which.

What ACP does, so the rest makes sense

ACP puts a hook in your coding agent. Before each tool call, the hook asks ACP for allow, ask or deny and gets an answer based on your rules. After the call, it sends the result for scanning and logging. Every call is logged with the user it ran as.

Three things to know before you read the mapping:

  • A new workspace starts in audit mode. Everything is recorded and nothing is held, except by the safety floor (force-push, destructive SQL through a database client, curl | sh and deletes outside the project wait for approval). Rules that ask or deny are ones you turn on after you’ve seen what your agents do.
  • Rules key on the tool, not the arguments. Bash.git.push: deny stops pushes. ACP can’t tell prod-db.internal from localhost.
  • The hook runs on the machine where the agent runs. A session that disables hooks disables it. If ACP is unreachable, interactive Claude Code sessions continue with a loud UNGOVERNED banner. Subagent, background and API sessions stay blocked.

Why this is a checklist item now

Enterprise security teams already use the OWASP web Top 10 as a vendor baseline, and the agentic list is heading the same way. Gravitee’s State of AI Agent Security report found only 14.4% of organizations send agents live with full security approval, 88% reported agent security incidents, and 45.6% still use shared API keys for agent-to-agent authentication. Those are Gravitee’s figures as of early 2026, not ours.


ASI-01: Agent Goal Hijack

The risk: Instructions hidden in a document, email or database record change what the agent is trying to do. A summary task turns into “send this data out.”

What a control plane does: It can’t stop the injection. That’s a model problem. It limits what a hijacked agent can do, because the check happens outside the agent. An agent that decides whether its own input is malicious can be talked into saying yes.

  • Rules per tool apply no matter what the agent was told. If Bash.curl is set to ask, the hijacked agent still waits for a human.
  • Holds put a person in front of high-consequence calls. The agent can want to send data out. The call waits until someone approves it.
  • The log records each call with the user, the tool and the decision, so you can reconstruct what happened.

Limits: the exfil guard that scans for secrets leaving in tool calls is off by default and turns on through presets. The safety floor only reads shell command text, so it doesn’t see MCP or other non-shell tools.


ASI-02: Tool Misuse and Exploitation

The risk: The agent uses a tool unsafely. It has too much access, passes bad arguments or chains calls with side effects nobody intended. It isn’t malicious. It’s doing what the model thought was helpful.

What a control plane does: Every call is a decision, made before it reaches the tool.

  • Per-call rules. An agent making 200 tool calls gets 200 checks. A rule can allow, ask or deny a tool, and a chained command like a && b | c is split so the strictest verdict wins.
  • Rules by tier. You can set Bash.rm and Bash.git.push to never for background and subagent sessions and leave interactive sessions on ask.
  • A spending cap. In a connected workspace you can set a maximum spend per period and have tool calls halt when it’s reached.

Limits: ACP can’t see inside the arguments beyond the command text. It won’t know that a database client points at production. SQL passed as a file, in-repo deletes and rm -rf $VAR aren’t on the floor.


ASI-03: Identity and Privilege Abuse

The risk: Agents run on shared or long-lived credentials. An agent acting for an intern uses the same key as one acting for the CFO.

What a control plane does: It attaches a person to each call.

  • Every call is logged against the user who ran it. You see which person’s session did what, not one anonymous service key.
  • Narrowed child keys. When a session starts a subagent, ACP can mint a child API key with narrower permissions than the parent’s, and the audit trail links back to the person who started it.

Limits: ACP doesn’t fix your backends’ own credentials. If the agent uses a shared database password, ACP logs the call but the database still sees one account. Whether a given tool call carries the user’s identity to a downstream API is up to that API.


ASI-04: Agentic Supply Chain Vulnerabilities

The risk: Tools, plugins and MCP servers get pulled in at run time, and the set changes. postmark-mcp showed a malicious package can reach production before anyone reviews it. Snyk reported that 13.4% of skills on ClawHub had at least one critical security issue, with 76 confirmed malicious payloads.

What a control plane does: It doesn’t vet packages. It limits and records what they do once running.

  • Rules apply to MCP tools too on the harnesses that route them through the hook. You can set an unfamiliar tool to ask.
  • The log shows which tool was called, by which agent, for which user. If a server turns out to be bad, you can query the blast radius.

Limits: ACP is not deny-by-default. A new workspace allows and logs. Unknown tools get no special treatment unless you write a rule or a preset does. And not every harness routes every tool through its hook, so check the coverage table for yours.


ASI-05: Unexpected Code Execution

The risk: The agent writes and runs code with the agent’s full permissions. Natural language becomes a way to run arbitrary commands.

What a control plane does: A shell command is a tool call, so it gets the same checks.

  • The safety floor holds the worst shell commands: curl | sh, destructive SQL through a database client, force-push, deletes outside the project. It always blocks rm -rf of your home or root, mkfs, disk wipes and fork bombs.
  • The log captures the command that ran and the outcome.

Limits: this is not a sandbox. A command the floor doesn’t recognize runs. For untrusted input, add an OS-level sandbox as well. See sandboxes and control planes.


ASI-06: Memory and Context Poisoning

The risk: An attacker poisons a RAG store, an embedding database or agent memory, and one bad document changes behavior across future sessions.

What a control plane does: Least, of the ten.

  • Tool results are scanned after the call. Recognized credential formats are redacted from stored previews.
  • The log helps with provenance. You can see which tool call brought content into a session.

Limits: ACP sees tool calls, not your vector store or the model’s memory. If the poisoned content doesn’t arrive through a tool call the hook sees, ACP doesn’t see it. Treat this risk as mostly outside what we do.


ASI-07: Insecure Inter-Agent Communication

The risk: Agents pass messages to each other with no authentication or authorization. Agent B does what Agent A says without checking that it was allowed to ask.

What a control plane does: It covers delegation inside a governed session.

  • Subagent calls are tiered and checked. Subagent and background sessions have their own rules and fail closed if ACP is unreachable.
  • Child keys narrow the permissions each hop gets, and the log ties the chain back to a person.

For the data shape of a chain, see our open ADCS spec.

Limits: this is for agents running under ACP’s hook. Messages between agents on other platforms don’t pass through us.


ASI-08: Cascading Failures

The risk: A small error spreads. One agent’s bad output becomes another’s input, or a retry loop floods shared systems.

What a control plane does: It puts brakes on cost and on unattended runs.

  • A spending cap can halt tool calls when you hit it.
  • Unattended sessions are stricter. In subagent, background and API sessions an ask becomes a deny plus a console approval, and they fail closed if ACP is down.
  • Each step is checked on its own. An approval covers one retry of the exact action, not the calls after it.

Limits: the cap counts spend and applies to a connected workspace. Local mode has no meter.


ASI-09: Human-Agent Trust Exploitation

The risk: A confident agent recommendation gets approved without scrutiny, even though it was built on bad data.

What a control plane does: It adds a pause and a record.

  • Holds. Risky calls wait for a person. In Claude Code a safety-floor hold shows inline. Everywhere else, and for holds from your own rules, the call is blocked, you approve it in the console or from the email, and the agent retries.
  • The log shows what the agent tried, what the human approved and what ran.

Limits: a hold only helps if the person reads it. The log is a record on ACP’s side, and the local audit.jsonl is a plain file on the same machine, so call it a record, not proof.


ASI-10: Rogue Agents

The risk: A compromised agent looks normal and passes authentication, then slowly leaks data or escalates.

What a control plane does: It bounds what such an agent can do and leaves a trail.

  • Rules limit the tools it can use without a human in the loop.
  • The log gives you behavior to look at: unusual call volume, tools outside its normal pattern, odd hours.
  • A spending cap limits the damage from an agent burning your budget.

Limits: detection is on you. ACP records, and the Activity view helps you read it. It doesn’t flag a rogue agent for you.


Least agency

OWASP’s central idea is “least agency”: give an agent the minimum autonomy a bounded task needs. That’s different from least privilege. Privilege is what the agent can touch. Agency is how many decisions it makes without a human and how far they reach.

OAuth scopes say which resource an agent can access. They don’t say how often, in what order or at what cost. Least agency needs a check on every call. That’s what the hook does.

The mapping at a glance

OWASP Risk What ACP does Main gap
ASI-01: Goal Hijack Per-call rules, holds, log Doesn’t stop the injection; exfil guard off by default
ASI-02: Tool Misuse Per-call rules by tool and tier, spending cap Rules key on the tool, not the arguments
ASI-03: Identity & Privilege Calls logged per user, narrowed child keys Backend credentials are still yours
ASI-04: Supply Chain Rules on MCP tools, log of which tool ran Not deny-by-default; coverage varies by harness
ASI-05: Code Execution Safety floor on shell commands, log Not a sandbox
ASI-06: Memory Poisoning Result scanning, provenance in the log Doesn’t see your stores or memory
ASI-07: Inter-Agent Comms Tiered subagent rules, child keys Only agents under the hook
ASI-08: Cascading Failures Spending cap, stricter unattended tiers Cap needs a connected workspace
ASI-09: Trust Exploitation Holds and a log Needs a person to read the hold
ASI-10: Rogue Agents Rules, log, spending cap You do the detection

Where to start

  1. Run in audit mode first and read the log. You learn which tools your agents call and as whom.
  2. Set rules on the few tools that can hurt you: rm, git push, curl and your database clients. Ask for interactive sessions, never for background ones.
  3. Add a sandbox if the agent reads untrusted input.

ACP is one way to do this. It is not an OWASP certification, and OWASP doesn’t certify products against this list.

Get started free · Reference architecture · Coverage by harness

Running coding agents? ACP records each tool call its hook sees and makes the dangerous shell commands (a force-push, destructive SQL, curl | sh) wait for you. One command, free up to 5 agents:

macOS · Linux · WSL
curl -fsSL https://agenticcontrolplane.com/install.sh | bash
Windows · PowerShell
irm https://agenticcontrolplane.com/install.ps1 | iex

What the installer writes  ·  Getting started

Share X HN LinkedIn
Get the next data drop
What agents actually cost, new tool-surface captures, and the occasional incident post-mortem — sent when we publish something worth your inbox, not on a schedule. Unsubscribe anytime.
Share: Twitter LinkedIn
Related posts

← back to blog