The Model Context Protocol specification treats user consent as a design principle applied to tool invocation, resource access, and sampling requests. The specification states that hosts must obtain explicit approval before a tool call executes, and that the request should be presented with enough information for a human to make an informed decision. This is a conceptual requirement, not a technical enforcement mechanism built into the wire protocol. MCP defines how a tool call request is formatted and transmitted using JSON-RPC, but it does not define how or whether a client actually pauses execution to collect approval. That responsibility sits entirely with the host application. As a result, two MCP-compliant clients can implement meaningfully different consent behavior while both remaining conformant with the specification.
Architectural Separation Between Protocol and Enforcement
MCP separates the protocol layer from the application layer by design. The protocol layer handles message exchange: tool call requests, resource reads, and sampling calls formatted as JSON-RPC. The host application layer handles everything related to consent capture, authorization checks, and enforcement logic. This separation is intentional and allows MCP to remain transport-agnostic, but it also means that consent enforcement is not something that can be verified by inspecting the protocol alone. Security engineers evaluating an MCP deployment need to look at the host and client implementation specifically, since the specification itself does not guarantee that a human approval step actually occurs before a tool executes.
Tool Annotations Are Advisory, Not Enforced
MCP allows servers to attach annotations to tool definitions, such as readOnlyHint or destructiveHint, intended to help a client decide how much scrutiny a given tool call warrants. These annotations can inform a consent prompt, for example flagging a destructive operation more prominently than a read-only one. However, the specification does not require clients to act on these annotations. A client can ignore them entirely and still be considered compliant. This creates inconsistency across implementations: one host might use annotations to drive tiered approval prompts, while another treats every tool call identically regardless of risk level. Enterprises should not assume annotation metadata alone is a control, since its effect depends entirely on whether the host chooses to honor it.
Where Enforcement Gaps Commonly Appear
Security research on MCP implementations has documented several patterns that undermine consent integrity even when the specification is nominally followed:
- Tool poisoning: a malicious or compromised server presents a tool definition that misleads the approval decision.
- Rug pull scenario: a server changes its tool definitions after a user has already granted consent, meaning the original approval no longer reflects what the tool actually does.
- Confused deputy behavior: in OAuth-based flows, authentication of a user or client is mistakenly treated as equivalent to authorization for a specific action.
None of these are protocol-level vulnerabilities in the strict sense. They are consequences of the specification leaving enforcement mechanics to implementers, combined with real-world implementations that have not closed these gaps consistently.
Implementation Considerations for Runtime Approval
Key distinction
Confirming a user's identity (authentication) is not the same as confirming that user is permitted to invoke a specific tool (authorization). Treating the two as equivalent is a documented source of confused deputy risk in MCP's OAuth-based flows.
Governance Implications for Enterprises
Because MCP delegates consent enforcement to the host application, protocol conformance alone does not give an enterprise a governance guarantee. Internal policy and technical controls are required to fill the gap the specification intentionally leaves open. This matters most in two areas. First, audit trails for tool-call approvals should be treated as a distinct governance requirement from general technical logging, particularly where evidence of authorized human review is needed for regulated processes. Second, the distinction between authentication and authorization in MCP's OAuth-based flow needs to be explicitly mapped to internal access control policy.
Runtime governance platforms can serve as the enforcement layer that implements organization-specific consent policy, approval routing, and audit logging across MCP servers, but this remains an implementation choice made outside the MCP specification itself, and enterprises should evaluate it as such rather than assuming it comes built in.