MCP Security Breaks When Capability Metadata Becomes Trust

With the Model Context Protocol (MCP), an AI agent does not need a custom interface to each data source or AI tool: it can discover and use these at runtime, without hard-coding knowledge about the tools and capabilities. This can make it harder for developers to know in advance which tools or API methods an agent may use. Because MCP servers can report metadata about tools an AI agent can use, these servers can affect what the AI believes it is allowed to do. This influences the AI’s decision-making.

MCP makes capability discovery dynamic

In order to make it easier for a language model to interact with external services, MCP servers advertise the tools, resources, and prompts available to an application. Applications may trust what an MCP server reports about tools, affecting the model’s behavior. If an MCP server changes a tool description (e.g., maliciously after being compromised), this could change the model’s behavior in undesirable ways. Since a language model can plan its actions based on machine-readable tool descriptions, these descriptions affect which tools it chooses.

The 2026 security guidance for MCP deployments highlights that this and other aspects of MCP, like tool calling, context sharing, and information exchanges, introduce additional security challenges that currently available security controls may not be able to manage. With MCP, teams need to manage how a model’s reasoning interacts with the capabilities available to it.


Tool descriptions become part of the attack surface

MCP security risks are complex because they involve trust relationships across agents, tools, servers, and permissions.

One security risk is that the tool a model believes it is calling may not match the one actually registered. Teams need to be confident that tool descriptions do not manipulate the model’s planning, that tool identities match what was registered, and that permissions have not expanded unexpectedly. Teams can help detect these changes by versioning or signing capability metadata and checking it against trusted records.

Another risk is that an agent may have more permissions than intended. Additionally, malicious tool descriptions could influence a model’s reasoning. These are similar to known AI security threats, such as excessive agency, insecure plugin design, and prompt injection attacks, in which malicious content from user input or retrieved content influences an agent’s reasoning. With MCP, these risks also become a protocol-level problem.

However, as these risks are subtle, they’re often overlooked. For example, the risk of malicious tool descriptions or server responses influencing an agent’s reasoning is less obvious than prompt injection attacks via user input. Applications also need to check where tool metadata and server responses come from before treating them as trusted context.

Authentication does not prove safe authority

When a resource is accessed, the requesting party should be authenticated (i.e., the system knows who is asking) as well as authorized (i.e., the system knows that the party should be allowed to access it). Authentication determines who a component is, but not what that component should be allowed to do. Authorization determines what a component should be allowed to do and is orthogonal to authentication. For example, an agent may be permitted to read one repository without being permitted to execute code, and a party may be permitted to query a database without being permitted to modify records.

Even if an MCP server is properly authenticated, it can still be overprivileged. Generated tool calls should be considered requests and vetted before execution. Specifically, the application should verify the requesting user and agent identities, the tool to be invoked, the resource being accessed, and whether the arguments are allowed by policy. This is important because context can influence the model, but it should not determine whether a request is authorized. These rules belong outside the model.

Composition creates transitive trust

Consider an agent using several MCP servers: one may provide data, another may execute code, and a third may interact with cloud resources. Individually, these servers may be performing legitimate functions. However, together they may present a risk.

Agents are capable of combining servers in new ways, where data from one could inform a decision to use a tool on another, and the output could then be used by a third. This is known as transitive trust and can present much more risk than may be apparent by looking at each server in isolation.

Agent security involves more than just authentication at an endpoint, and therefore security teams need to explicitly model potential threats based on server combinations, not just individual servers. This type of multi-step authority is one of many reasons that agent behavior is difficult to assess.

Treat MCP as an execution supply chain

To better threat-model agents, consider MCP as an execution supply chain. Servers provide capabilities and metadata describing them. The model selects a tool, and application logic decides whether the call can run. Each stage of the process may affect the final outcome.

Since MCP servers provide potentially powerful capabilities, keeping track of which ones exist, who is responsible for them, which versions are deployed, what tools they expose, and which identities can use them is important. Changing tool metadata or permissions should be subject to the same rigor as changing executable code.

Being able to understand why an AI system did something unexpected is also valuable. Teams need to see the context that influenced the AI system’s choice of a particular tool, the arguments the model proposed for that tool, the deterministic policy decision that allowed this tool to be used, and finally what happened when the tool was invoked downstream. Missing any pieces of this puzzle makes a harmful action harder to differentiate from a normal API call.

MCP enables new integrations between AI and existing infrastructure by making it easier for AI to use existing tools and services. Using MCP securely requires care to make sure this ease of use doesn’t lead teams to trust MCP servers too much. The policy decision associated with an MCP call, not the call itself, is the critical security boundary.

Capabilities need versioned consent

Introducing new functions on an MCP server is now possible without requiring the application owner to update the application code, allowing agents access to more functionality. While this is extremely convenient, teams will want to think about the security implications of adding new functionality, changing existing functionality, If no one reviews these changes, an agent could end up with more authority than its owner intended.

The recommendation is for teams to track capabilities exposed by MCP servers (including functionality and permissions) via versioned metadata and approve changes before production agents can use them. This allows new tools, significant changes to permissions or capabilities, and material changes to descriptions to be approved before they go live, while preserving the convenience of discovering tools dynamically as needed.

ABOUT THE AUTHOR


Leave a Comment

Your email address will not be published. Required fields are marked *


Shopping Cart