The MCP Security Checklist for Enterprise Teams
The postmark-mcp server silently BCC’d every outgoing email to an attacker-controlled address. It ran undetected for weeks. Dozens of CVEs have been filed against MCP servers in a few months. Trend Micro found 492 exposed MCP servers with no authentication at all.
Our own scans of the ecosystem point the same way. 29.6% of MCP servers expose high-risk input parameters with no validation constraints. 74.9% document no audit logging. 85% of paid-API proxies have no rate limits. These are findings from our scans in early 2026, and the ecosystem moves fast.
OWASP published the Top 10 for Agentic Applications, peer-reviewed by over 100 researchers from NIST, the European Commission and the Alan Turing Institute.
The question is whether your team deploys MCP servers with a security baseline or without one.
Why MCP needs a checklist
The registry grows by hundreds of servers a month. Most are small community projects, thin wrappers around APIs, databases and cloud services. Publishing is easy. Auditing is hard.
The protocol defines tool schemas, transports and resource URIs. It does not define authentication, authorization, audit logging, rate limiting or input validation. Each server author decides. Security teams already use checklists for web apps (OWASP Top 10), cloud (CIS Benchmarks) and APIs (OAuth best practices). MCP needs one too.
For each point below you get the requirement, what to verify, and what ACP does about it today. Where ACP doesn’t cover a point, the section says so.
The 10-point checklist
1. Identity verification
Requirement: every request to an MCP server carries a verified identity. No anonymous tool access.
An MCP tool call arrives at the server with parameters and nothing else. No user ID, no session token. A compromised agent has the same authority as a legitimate one, and the audit logs, if they exist, can’t say who did what.
What to verify:
- Every tool call is authenticated with a JWT or OAuth token before it reaches the server
- The token is checked on every call, not just at session start
- User identity reaches the backend, closing the three-party identity gap
- Tokens are short-lived and scoped to the task, not long-lived service credentials
What ACP does: every call that goes through the ACP hook carries the identity of the API key or login behind it, and the log records it. For servers you run yourself, the open-source identifiabl package verifies JWTs against your identity provider.
2. Authentication and authorization
Requirement: separate who you are from what you can do, and scope permissions per tool.
Authentication asks “who is this?” Authorization asks “what can they do?” Many MCP deployments skip both. 45.6% of organizations still use shared API keys for agent authentication, so every agent has the same permissions whatever user it acts for.
What to verify:
- Agents have no permissions until you grant them
- Permissions are per tool, not per server, so a CRM connector can expose
readwithoutwriteordelete - Authorization is checked on every call: 200 tool calls, 200 decisions
- The intern’s agent gets intern-level access
What ACP does: rules are Allow, Ask first or Never, keyed by tool (Bash.rm, a specific MCP tool) and set per tier (interactive, subagent, background, API). The most specific key wins. A new workspace starts in audit mode, so nothing is denied until you turn on enforcement. The rules page shows how to set them.
3. PII detection and handling
Requirement: scan inputs and outputs for PII before they reach external services.
MCP servers pass data between agents and backends. That data often holds names, emails, phone numbers, SSNs and card numbers. The agent doesn’t know. The server doesn’t check. The data ends up in plaintext logs or third-party systems.
What to verify:
- Data in tool calls is scanned for PII before it reaches external services
- Detected PII is redacted, masked or flagged
- Detection covers both inputs and outputs
- Detection rules match your compliance needs (GDPR, HIPAA, PCI DSS)
What ACP does: credentials in recognised formats (GitHub and Anthropic tokens, private keys, passwords in URLs) are redacted from the stored log preview. That matcher is built for precision, so an unfamiliar token shape can get through. The open-source transformabl package does PII detection for servers you run yourself.
4. Rate limiting and budget controls
Requirement: stop runaway agents from burning through quotas and budgets.
An agent stuck in a retry loop against an MCP server that proxies OpenAI’s API can cost $1,080 an hour. The MCP spec has no rate limit primitives, no retry-after signal and no circuit breaker.
What to verify:
- Per-user and per-agent rate limits are enforced at a gateway
- Budget caps limit spend per user, agent and time window
- Calls stop after consecutive failures
- Limits hold no matter how many agents call the same server
What ACP does: the Policies page has a rate limit for each tier. Settings, then Limits has a Spending Budget that can halt tool calls when the cap is reached. The budget counts model spend ACP can see. See Stop your AI agent from burning through your API budget. ACP doesn’t have a circuit breaker for failing servers.
5. Audit logging
Requirement: every tool call logged with who, what, when and the result.
74.9% of MCP servers have no documented audit capability, and among servers handling critical data the rate is the same: 74%. SOC 2, HIPAA, GDPR and PCI DSS all expect attributable audit trails. MCP servers can’t give you one, because the protocol doesn’t carry user identity.
What to verify:
- Each call is logged with identity, tool, parameters, a result summary, timestamp and latency
- The policy decision is logged with it: allowed or not, which rule matched
- Logs are structured, searchable and exportable
- Logs can’t be edited by whoever compromised the agent
What ACP does: every governed call is recorded with the agent, session, tool, input preview, decision and outcome, and the Sessions view lays one run out call by call. The log lives in the ACP gateway. In --local mode the log is ~/.acp/audit.jsonl, a plain file on the same machine. That is a record, not tamper-proof evidence. If you need logs the agent can’t touch, export them somewhere it can’t write.
6. SSRF protection
Requirement: MCP servers that make HTTP calls must validate URLs and block internal network access.
831 MCP servers accept URL parameters such as endpoints, webhook addresses and redirect URIs. A prompt injection can point them at internal addresses: the cloud metadata endpoint (169.254.169.254), http://localhost:6379/ (Redis) or an internal admin page. The server makes the request.
What to verify:
- Outbound URLs are checked against an allowlist
- Internal ranges (10.x, 172.16-31.x, 192.168.x, 169.254.x, localhost) are blocked by default
- Cloud metadata endpoints are blocked explicitly
- The check happens before the request is made
What ACP does: for coding agents, you can ask before every outbound curl and allow the hosts you trust by name (Bash.curl: ask, then Bash.curl.api.github.com: allow). The same shape works for WebFetch.<host>. This governs what the agent runs, not what an MCP server does inside its own process. For that, the open-source proxyabl package validates outbound URLs for servers you run yourself.
7. Input validation
Requirement: validate tool inputs against schemas before they run. Don’t trust the model.
MCP uses JSON Schema for tool inputs, but a schema is not validation. It says "type": "string" and stops. The constraining keywords (pattern, format, enum, maxLength) are optional and rarely used. We found 4,512 high-risk input parameters across 2,432 servers that accept whatever the model sends, including path traversal sequences, SQL injection payloads and shell metacharacters.
What to verify:
- Inputs are validated against schemas with constraining keywords
- File paths are stripped of traversal sequences (
../) - SQL uses parameterized queries or allowlists
- URLs are checked for SSRF patterns (see point 6)
- Shell metacharacters are rejected in command parameters
What ACP does: this is mostly the MCP server’s job. ACP’s safety floor reads shell command text and holds a short list of destructive commands: force-push, destructive SQL through a database client, curl | sh, and deletes outside the project. It doesn’t validate the arguments of MCP tools. Treat this point as yours to cover in the server.
8. Supply chain verification
Requirement: know what MCP servers you run. Pin versions. Scan for vulnerabilities.
The first malicious MCP package shipped before anyone thought to look. Snyk found 13.4% of skills on ClawHub carried at least one critical security issue, with 76 confirmed malicious payloads. Our audit of 7,522 skills found 284 likely threats after deep analysis. MCP servers are fetched dynamically and updated silently.
What to verify:
- Every MCP server is inventoried with name, version and source
- Versions are pinned, with no automatic updates without review
- Servers are scanned for known vulnerabilities before deployment
- New or unknown tools have no permissions until granted
- A compromised server can be removed immediately
What ACP does: it doesn’t pin or scan servers. It does show you every tool that agents actually call, in the Activity log, so you can see what is in use. A tool you set to Never stays blocked. Pinning and scanning need your own tooling.
9. Approval workflows
Requirement: high-risk actions need a human to approve them before they run.
An agent that deletes records, emails users or provisions infrastructure without confirmation is an autonomous system with no oversight. The EU AI Act’s Article 14 requires human oversight of high-risk AI systems. OWASP’s core advice is “Least Agency”: the minimum autonomy needed for the task.
What to verify:
- High-consequence actions are listed: database writes, email, payments, infrastructure changes, data exports
- Those actions need explicit approval before they run
- The approval is logged: who, when, what
- The approval shows the action, its parameters and the risk, so it doesn’t turn into “click OK to continue”
What ACP does: a rule set to Ask first holds the call until someone approves it. Only Claude Code shows the hold in the session. On other harnesses the call is blocked, you approve it on the console Approvals page or from the email, and then the agent retries. An unanswered request expires and counts as denied. Approvals are recorded in the log.
10. Incident response
Requirement: have a plan for when things go wrong. Audit trails make forensics possible.
When an MCP server is compromised you need four answers fast. What happened? Who was affected? How far did it spread? Is it still happening? Without identity-attributed logs you can’t answer any of them. Without rate limits the blast radius has no edge. Without permission rules the server had access to everything.
What to verify:
- Your playbooks include MCP server compromise
- Logs are kept long enough for your compliance needs (typically 90 days to 7 years)
- Alerts fire on unusual patterns: odd call frequency, off-hours access, tools outside the normal set
- A compromised server can be cut off per server, per agent and per user
- You can rebuild the chain from user to agent to tool to outcome
What ACP does: the log gives you the chain from session to tool to decision. Setting a tool to Never blocks it for that tier. Approval requests email the workspace owner. ACP doesn’t do anomaly alerting, so build that on top of an export if you need it.
How ACP maps to the checklist
| # | Checklist item | Covered by ACP today |
|---|---|---|
| 1 | Identity verification | Key or login identity on every governed call; JWT verification in open-source identifiabl |
| 2 | Authentication and authorization | Allow / Ask first / Never rules by tool and tier |
| 3 | PII detection and handling | Credential redaction in stored previews; open-source transformabl for PII |
| 4 | Rate limiting and budgets | Per-tier rate limits; Spending Budget with optional halt |
| 5 | Audit logging | One log of every governed call, with session view |
| 6 | SSRF protection | Ask or allow outbound hosts for curl and WebFetch; open-source proxyabl for your own servers |
| 7 | Input validation | Not covered; the safety floor holds a short list of destructive shell commands |
| 8 | Supply chain verification | Not covered; tool inventory in the Activity log |
| 9 | Approval workflows | Ask first, with approval on the console or email |
| 10 | Incident response | Log and Never rules; no alerting |
That is a partial map, and it should be. A gateway or hook can cover points 1 to 6, 9 and part of 10. Points 7 and 8 live in the server and your build pipeline.
Getting started
Start with identity (point 1) and audit logging (point 5). Those two close the most common compliance gaps and give you the record you need for everything else.
The free tier covers up to 5 initiating agents. The Agentic Control Plane installs as a hook on the machines that run your agents:
curl -sf https://agenticcontrolplane.com/install.sh | bash
Correction (2026-07-18): An earlier version of this post cited “30+ CVEs in MCP servers within 60 days, 82% involving path traversal” and attributed the figures to Invariant Labs. The cited page contains neither figure, and we could not source the 82% claim anywhere, so both have been removed. The Snyk ClawHub statistic has also been corrected from “12% of published skills were compromised” to Snyk’s actual finding: 13.4% of skills carried at least one critical security issue, with 76 confirmed malicious payloads.
Update (2026-11-08): the “How ACP addresses this” sections were rewritten to describe what ACP does today. The earlier version claimed coverage for input validation, supply chain vetting, immutable logs and several controls ACP does not provide.
Get started free · Reference architecture · OWASP Agentic Top 10 mapping
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