MCP Security: Who Decides What an Agent Can Call?
A developer starts an MCP server, connects it to Claude Desktop, and ten minutes later an agent is querying their production CRM. The tool call works. The request goes out, the result comes back.
Nobody checked whether that agent should see customer data. Nobody logged which records came back or who asked. The call succeeded, and no rule was ever consulted.
MCP isn’t built to supply those rules. It moves tool calls, which makes it a data plane. Allowing, asking, denying and logging are a control plane’s job, and you add that yourself.
MCP is a data plane
Some posts and talks call MCP “the control plane of agentic AI.” That’s understandable, since MCP is the most widely adopted standard in the space. But it’s a protocol for moving requests. It defines JSON-RPC methods for tool discovery (tools/list) and tool calls (tools/call), and a shape for the results.
The spec treats tools as “model-controlled”: the model decides what to call, when and with what arguments. The protocol has no policy language for saying which user may call which tool. It has no audit log format, no PII detection and no spend limits. Newer revisions do define an optional OAuth-based authorization flow for HTTP servers. That helps a server know who connected. It doesn’t decide which tool calls are allowed once they’re connected.
None of this is a defect. A protocol that moves calls shouldn’t also be the thing that approves them. The trouble starts when a team deploys MCP and assumes governance came with it.
You already know this split
In networking, the data plane forwards packets. The control plane decides which packets are allowed: routing, access lists, firewall rules.
Kubernetes does the same. The kubelet runs containers. The API server handles admission control and RBAC. In a service mesh, Envoy moves traffic and Istio sets who may talk to whom.
Nobody runs a production network with only the first half. An MCP server in production with nothing checking its calls is exactly that.
What MCP does
Before MCP, each agent framework had its own way to call tools. LangChain had one format, AutoGen another, and custom integrations used whatever JSON the developer liked. MCP gave everyone one interface.
It handles:
- Tool discovery:
tools/listreturns the tools and their input schemas - Tool calls:
tools/callsends a structured request to the server - Responses: text, images and resources come back in a predictable shape
- Transport: stdio for local servers, HTTP for remote ones
You write an integration once and it works in every client. That’s the job, and it does it well.
What MCP leaves to you
Which calls are allowed. There’s no built-in rule for “this user may call this tool but not that one.” If a server lists a tool, any connected client can usually call it. You can write that logic inside each server. Most people don’t.
An audit log. MCP defines no log format. If your security team asks for every AI-driven access to customer data last quarter, attributed to specific people, the protocol has nothing to offer. Each server logs what it logs, if anything.
A look at the data. Arguments go to the server and results come back to the model. The protocol checks neither direction for sensitive content.
Limits on loops and spend. An agent stuck retrying can hit a server over and over. Nothing in MCP caps that, or prices it. A single runaway agent can burn through your API budget before anyone looks.
Separation between tenants. In a multi-tenant setup, keeping one customer’s agents away from another’s tools is up to the implementer.
What has gone wrong without those checks
These are reports from other people’s research. We haven’t reproduced them.
Trend Micro reported in early 2026 that it found 492 exposed MCP servers with no authentication. Any caller could run tools against live backends.
A package called postmark-mcp was reported as the first confirmed malicious MCP server. It quietly BCC’d outgoing email to an attacker. The tool listing looked normal, and the bad behavior was in the code that ran.
Snyk’s audit of ClawHub found that 13.4% of the skills it scanned had at least one critical security issue, including 76 confirmed malicious payloads. ClawHub skills aren’t MCP servers, but the lesson carries over. A clean-looking description tells you little about what the code does.
None of these are exotic. A service with no access control gets probed. One with no log can’t tell you what happened.
What a control plane adds
The agentic control plane doesn’t replace MCP. It checks the calls MCP carries, before they run.
For coding agents, that’s what Agentic Control Plane (ACP) does. It installs a hook in the harness (Claude Code, Cursor, Codex and others). Every tool call, including calls to MCP servers, goes through the hook first. ACP answers allow, ask or deny, and writes one log entry that names the person and the agent. The coverage page lists which harnesses pass MCP calls through the hook.
Here’s what that gives you, and where it stops.
Allow, ask or deny per tool. You can write a rule like “ask before this MCP tool runs” or “never call that one.” The rule checks the tool name and the arguments. A new workspace starts in audit mode, so everything is recorded and nothing is held except a short list of dangerous shell commands. You turn rules on after you’ve seen what your agents call.
One log. Every call is recorded with who ran it, in which harness, which rule applied and what the outcome was. For model calls routed through ACP, it also records the cost.
A check on results. On harnesses whose hook can rewrite tool output (Claude Code is one), sensitive values can be redacted before the result goes back to the model. Others record the finding in the log only.
A spend cap, with limits. Workspace-billed model traffic is subject to a daily cost cap at the gateway. If you use your own subscription or API key, ACP meters the spend but can’t cap an account it doesn’t hold.
Where it stops. ACP runs as a hook on the machine where the agent runs. If someone turns hooks off in the harness, the checks stop. The built-in list of dangerous commands (force-push, destructive SQL, curl | sh) only reads shell commands, so it doesn’t cover MCP calls. For those you write your own rules.
If you’re building an MCP server yourself, GatewayStack, the open source library behind ACP, can verify the caller’s JWT on every request and pass the user’s identity through to your tools. It’s MIT licensed, and you can adopt it alongside the servers you already run.
The request flow
User → LLM → MCP Client → Control Plane → MCP Server → Backend
↓
Identity ✓
Policy ✓ (allow / ask / deny)
Redaction ✓ (where the harness allows)
Audit ✓
MCP carries the call. The control plane decides whether it goes through. If you swap MCP for another protocol, the check still sits on the tool call.
Why the mix-up matters
If a team believes the protocol handles governance, nobody builds any. The distance between what they think is covered and what is covered is where things go wrong.
Web teams made the same mistake with HTTPS. “We have TLS, so we’re secure.” TLS protects the transport. It doesn’t say who the user is, whether the request is allowed, or what happened. Agent teams are making that mistake again, one layer up.
The CSA’s framework for the Agentic Control Plane treats governance as its own layer apart from execution. The OWASP Top 10 for Agentic AI points the same way. MCP is needed. It isn’t enough on its own.
Where to start
If you run MCP servers, or plan to, ask three things.
-
Who is calling? Does your backend know which person started each tool call? If it sees anonymous JSON-RPC or a shared service account, you have a gap. Start with identity.
-
What’s allowed? Is anything outside the server deciding which tools each user or agent may call? If every listed tool accepts every client, every tool is open. Read about runtime authorization.
-
Can you show what happened? Could you list every MCP tool call from the last 30 days, with who made it and what the rule said? If your logs read
crm:read 200with no name, an auditor will notice. See what an audit trail needs.
Get started free · Reference architecture · Data plane vs control plane
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:
curl -fsSL https://agenticcontrolplane.com/install.sh | bash
irm https://agenticcontrolplane.com/install.ps1 | iex