The Model Context Protocol (MCP) has become the dominant standard for connecting AI agents to external tools and data sources. Anthropic released the open specification in late 2024, and by mid-2025 OpenAI, Microsoft, Google and dozens of enterprise vendors had adopted it. Thousands of community MCP servers appeared on GitHub during 2025. CData, one enterprise vendor, reported 294 downloads of its MCP servers in their first six weeks.
The protocol works. The analogy of “USB-C for AI agents” holds: MCP provides a standard interface so any model can call any tool through a consistent schema. That is a real engineering improvement over writing a custom API wrapper for every integration.
Standardising the interface does not standardise governance. For a law firm, or any business answerable to a regulator, connecting an agent to a database is the easy part. The harder question is whether that connection can be audited, scoped, monitored and controlled to the standard a regulator expects.
The answer, as of early 2026, is: not with MCP alone.
What MCP covers
The MCP specification defines a JSON-RPC transport layer with three core primitives: tools (functions an agent can call), resources (data an agent can read) and prompts (templates for agent instructions). Each tool exposes a typed schema describing its inputs and outputs.
The June 2025 specification update added OAuth 2.1 as the standard authentication mechanism. MCP servers are now classified as OAuth Resource Servers. Clients must implement RFC 8707 Resource Indicators, which scope access tokens to a specific server. This prevents a compromised server from reusing a token to access other resources.
The November 2025 revision added experimental support for long-running tasks, incremental scope consent and clearer rules for returning tool errors. These help production deployments.
MCP now provides typed tool schemas, OAuth 2.1 authentication, token scoping via resource indicators, capability negotiation and structured error responses.
What MCP does not cover
The specification is deliberately a transport protocol. It defines how an agent talks to a tool. It does not define what happens around that conversation. For regulated work, the gaps are significant.
No standardised audit logging
MCP does not specify how tool calls should be logged, what metadata should be captured, how logs should be stored or for how long. There is no required format for recording which agent called which tool, with what parameters, at what time, and what was returned.
The SRA expects law firms to be able to show how client data was handled, and financial regulators expect firms to evidence their decision-making. Without immutable, structured audit trails of every tool invocation, an MCP deployment cannot satisfy these requirements. The protocol leaves this entirely to the implementer.
No data residency controls
MCP does not address where servers run or where data transits. A tool call from an agent in London might route through an MCP server hosted in the United States, processing UK client data in a jurisdiction that does not meet UK GDPR requirements. The protocol has no mechanism to express or enforce data residency constraints.
No rate limiting or resource governance
The specification does not define rate limiting, concurrency controls or cost boundaries for tool invocations. An agent with access to a database query tool can, in principle, execute thousands of queries per second. There is no protocol-level mechanism to prevent runaway costs or resource exhaustion.
No policy evaluation framework
MCP does not include a concept of policies that govern when a tool may be called. There is no way to express rules like “this tool requires human approval for transactions above a threshold” or “this tool may only be invoked during business hours” within the protocol itself.
No compliance metadata
Tool schemas describe inputs and outputs but carry no metadata about data classification, regulatory scope or compliance requirements. An MCP server exposing access to client records looks identical at the protocol level to one exposing a weather API.
The security risks that matter
The governance gaps are compounded by active security risks that Microsoft, Red Hat, Pillar Security and Palo Alto Unit 42 have documented in detail.
Prompt injection through tool results
Prompt injection is the most serious risk for regulated deployments. When an MCP server returns data to an agent, that data enters the model context. If the returned data contains hidden instructions, the agent may execute them. Microsoft’s research describes cross-tool injection scenarios where a document fetched via one tool contains embedded commands that trigger actions through a different tool.
Researchers have shown it working. In July 2025, General Analysis demonstrated a Cursor agent connected to Supabase’s MCP server with privileged access reading a support ticket that contained hidden instructions, then leaking integration tokens back into the ticket thread. Cato Networks showed a similar attack against Atlassian’s Jira Service Management MCP integration through poisoned support tickets.
Over-permissioning
MCP servers typically request broad permission scopes. As Pillar Security notes, servers often hold credentials for several services and run actions with them, which makes each one a high-value target. A stolen token with full access can be reused anywhere that service is reachable. Concentrating credentials in one protocol layer changes the attack surface.
Tool poisoning
MCP tool descriptions are loaded directly into the model context. Attackers can embed hidden instructions in tool metadata. Microsoft’s Plug, Play, and Prey analysis describes scenarios where a weather-checking tool description secretly instructs the agent to exfiltrate private conversations. Equixly found command injection flaws in 43% of the MCP servers it tested.
Supply chain risks
With thousands of community MCP servers available, the supply chain risk is substantial. CVE-2025-6514, found by JFrog, showed how a flaw in the OAuth flow of mcp-remote, a widely used proxy package, allowed remote code execution on the machine of anyone who connected to a malicious server.
What a compliant MCP deployment requires
Deploying MCP servers in a regulated environment requires an infrastructure layer above the protocol that provides the governance MCP itself does not include.
Scoped permissions with least privilege
Every MCP server should expose the minimum set of tools required for its function. OAuth tokens should be scoped to individual servers using resource indicators. Tools that access sensitive data should require separate, time-limited credentials rather than long-lived tokens shared across services.
Immutable audit logging of all tool calls
Every MCP tool invocation must be logged with: the calling agent identity, the tool name and version, input parameters, the full response, a timestamp and the execution context. Logs must be append-only, tamper-evident and stored for the retention period required by the applicable regulatory framework. This logging cannot be optional or best-effort. It has to be built into the architecture.
Data residency constraints on server placement
MCP servers that process regulated data must run within the required jurisdiction. That means deploying servers in specific regions and routing tool calls through infrastructure that keeps data inside the required boundaries. The deployment topology must be documented and auditable.
Policy-as-code evaluation before tool execution
Before an MCP tool call reaches the server, a policy engine should evaluate whether the call is permitted. Policies can encode rules such as “this agent may only query documents in its assigned client project”, “this tool requires human approval above a specified threshold” or “this data source may not be accessed outside business hours”. These policies should be version-controlled, testable and auditable.
Input and output filtering
All data returned from MCP servers should pass through a filtering layer that detects and strips potential injection payloads before the data enters the model context. Similarly, tool inputs should be validated against expected schemas and sanitised for dangerous patterns. The defence is not foolproof, but it makes injection attacks much harder.
Server provenance and integrity verification
Organisations should maintain an approved registry of MCP servers, with cryptographic verification of server identity and integrity. Community servers should undergo security review before deployment. Runtime monitoring should detect unauthorised servers or unexpected changes to tool descriptions.
The role of workflow orchestration
The governance controls described above require coordination. An individual MCP server does not know about data residency policies, audit requirements or approval workflows. These are concerns of the system that orchestrates agent behaviour.
Workflow orchestration engines sit above MCP and provide the execution framework for governance. An orchestration layer can intercept tool calls before they reach MCP servers, evaluate policies, log the interaction, enforce rate limits and route calls to jurisdiction-appropriate infrastructure.
That split makes MCP workable for regulated work: the protocol handles the transport, and the orchestration layer handles the governance. CompleteFlow follows this pattern. MCP tool calls run inside workflows of fixed, versioned steps, with audit logging, approval steps, each user’s own credentials and data kept in the client’s chosen region.
The 2026 MCP roadmap acknowledges some of these gaps. It lists enterprise requirements such as audit trails, SSO-integrated authentication, gateway behaviour and configuration portability. A roadmap describes intentions, though, and organisations deploying MCP for regulated work today need the governance layer now.
Conclusion
MCP is a good protocol. It solves a real engineering problem, and every major AI vendor has adopted it. It is a transport protocol, though, and the specification does not claim to be a governance framework.
For organisations with regulatory obligations, running MCP servers without a governance layer above them is not workable. The security risks are documented and have been demonstrated. The compliance gaps are structural and well understood.
Avoiding MCP is not the answer. Deploy it inside an architecture that adds the audit trails, access controls, data boundaries and policy enforcement the protocol does not yet include. The technical overview shows how CompleteFlow does this.