MCP Security

Model Context Protocol Consent and Runtime Approval

Model Context Protocol requires that hosts obtain explicit user consent before a tool call, resource access, or sampling request executes, but the specification does not define how that consent is enforced. Enforcement logic lives entirely in the host application, meaning actual runtime approval behavior depends on implementation quality, not protocol guarantees.

Authorization Depends on Transport

MCP's authorization model differs significantly depending on transport type, which has direct implications for how enforcement should be architected.

  1. 1

    Local vs. Remote MCP Authorization

    Local, stdio-based servers typically inherit the host process's permissions and rely on OS-level controls rather than MCP-native mechanisms. Remote, HTTP-based servers can use a formal OAuth 2.1-based authorization flow, which introduces distinct governance considerations covered below.

Where Consent Decisions Occur in MCP

Consent and enforcement responsibilities are distributed across four distinct points in a typical MCP deployment.

Protocol Layer

Defines message formats for tool calls, resource requests, and sampling. No enforcement logic lives here.

Host Application

Responsible for capturing user consent and deciding whether a request proceeds.

Authorization Server

For remote MCP servers, mediates OAuth-based tokens scoping permitted actions.

Policy Enforcement Point

Optional gateway or proxy enterprises add to centralize approval routing and logging.

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.

Frequently Asked Questions

Does MCP guarantee that tool calls require human approval?

No. The specification states that hosts should obtain consent, but enforcement is implemented by the host application, not the protocol. Whether approval actually occurs depends on the specific client and host implementation.

Are local and remote MCP servers governed the same way?

No. Remote HTTP-based servers can use a formal OAuth 2.1-based authorization flow. Local stdio-based servers typically run with the host process's permissions, so OS-level controls, not MCP-native ones, often determine actual risk exposure.

What is a rug pull risk in MCP?

It refers to a server changing its tool definitions after a user has already granted consent, meaning the original approval no longer reflects the tool's actual behavior. This is a documented security concern, not a protocol-defined safeguard.

Do tool annotations like destructiveHint enforce stricter approval?

Not automatically. Annotations are advisory metadata a server can supply. Clients are not required to act on them, so their effect on consent prompts depends entirely on whether the host implementation chooses to use them.

Assess Your MCP Consent and Approval Architecture

Understanding where consent decisions occur is the first step to closing enforcement gaps in production MCP deployments.

Explore Runtime Governance