/ What Is Model Context Protocol (MCP)?
What Is Model Context Protocol (MCP)?
The Model Context Protocol (MCP) is an open standard, released by Anthropic in 2024, that lets AI models connect directly to an organization’s live data and tools without custom code. Anthropic’s own documentation describes MCP as “a USB-C port for AI applications”: one connector for any compatible model or tool. That same universal connector is also a universal entry point for attackers, so it needs the same protection as every other layer of zero trust architecture.
Key Takeaways
• MCP is an open standard developed by Anthropic that allows AI models to connect directly to live enterprise data and tools.
• MCP solves the M x N integration problem by providing a single connection method for teams to use across all AI systems, which is why security professionals refer to this connection method as the "USB-C" of AI.
• Every MCP connection runs through three roles (host, client, and server) and two transport methods (stdio and SSE), each with different exposure to the network.
• MCP's three primitives (prompts, resources, and tools) each hand control to a different party. Tools carry the highest risk because the model decides on its own when to call one.
• MCP shifts the trust boundary by turning AI from a passive chat interface into an active, autonomous agent. Indirect prompt injection and the confused deputy problem let attackers hijack an agent and trigger high-privilege actions, so network-level zero trust controls must protect local systems and sensitive data.
• The vendor-neutral Agentic AI Foundation now governs MCP, and more than 10,000 active public MCP servers are in use. No single vendor is responsible for securing an enterprise deployment.
• Zscaler ThreatLabz data shows attackers can compromise unprotected AI systems in minutes, which makes zero trust practices like mutual TLS, inline inspection, and continuous discovery essential for every MCP server an organization runs.
The Evolution of AI Context: Moving Beyond Static Models
Legacy AI models operated solely on what they were trained on. To generate real business value, models need to read, write, and act on current information inside the organization.
Why AI Models Need MCP: The Custom Integration Problem
A trained model knows only what existed at its cutoff. It doesn’t know about changes a sales team made an hour ago, the ticket support closed minutes before the model runs, or the file finance saved yesterday. To make relevant decisions, the AI model needs safe, governed, real-time access to current data.
Before MCP, engineering teams solved this with custom code. Every model needed its own integration to every database, SaaS application, and internal tool. Connect three models to four systems, and the result is 12 separate integrations to build, secure, and maintain. This is the M x N problem, and it scales poorly. Each new model or data source multiplies the number of connections a security team has to write, patch, and monitor, which creates inevitable vulnerabilities.
The scale of the challenge is measurable. Zscaler ThreatLabz found that enterprise AI and machine learning (AI/ML) activity grew 91% year over year in 2025, spreading across more than 3,400 applications. Data transfers to AI tools rose 93% in the same period, reaching 18,033 terabytes. Few security teams can hand-code and secure a custom integration for every one of those connections. Managing that volume without a shared standard has become an operational security bottleneck.
How MCP Acts as the USB-C for AI Applications
Anthropic built MCP to solve that problem with an open standard: a common architecture for every client and server relationship. In this model, each AI application acts as an MCP client, and each data source or tool exposes an MCP server. Any client may communicate with any server with no additional custom coding needed between them.
MCP changes the math. With M models and N data sources, teams once had to write M x N integrations. With MCP, they build M clients and N servers, and every one of them interoperates.
Take the earlier example. Three models and four systems drop from 12 integrations to 7. The gap widens with every model or system added, so AI adoption can outpace the integration workload. That math explains how fast MCP has spread.
How the Model Context Protocol Works
MCP runs on three defined roles and one common message format. Understanding each part shows where the security risk sits.
The Core Triad: Hosts, Clients, and Servers
Before MCP, developers built a custom connector between every model and every data source they wanted it to reach. MCP replaces that tangle with a three-part structure, and each part has a distinct job.
- Host: the AI application a user works in, such as Claude Desktop or an AI-enabled integrated development environment (IDE)
- Client: the component inside the host that opens and holds a secure connection to a single server
- Server: the lightweight service that supplies data, files, or tools to the client
.png)
Within this host sits the MCP client. This dedicated component opens and maintains a connection to a single server. Multiple clients may operate within a given host, and each client controls its own independent connection to a server. As such, if a session fails or is compromised, it cannot cause a cascading effect on other sessions.
The MCP server is the lightweight service that presents enterprise data, tools, and prompt templates to the client in a format usable by the model. A server may reside locally on a laptop, accessing local files, or it may run in the cloud as a front end to an enterprise database that many users share. Regardless of where it runs, a server presents only what it was designed and authorized to present.
How the Transport Layer and JSON-RPC Move Messages
All traffic between a client and a server uses JSON-RPC 2.0, a simple request-and-response format that gives every MCP message the same structure. How those messages travel is the transport layer’s job, and MCP defines two transport methods.
Standard Input/Output (stdio) transports all data within one machine. The client runs the server as a process, and the two exchange JSON-RPC messages via the standard input/output streams. Because no network ports are opened during this exchange, it can be very fast and provides good protection against outside interference.
Server-Sent Events (SSE) transmit data over HTTP and are designed to allow communication with servers teams have no local control over. The client opens one long-lived connection to receive server events and sends its own requests to a separate endpoint. SSE lets teams communicate over the internet using shared systems, and that flexibility puts the burden on the security team to get authentication and encryption right.
The table below summarizes the differences between these two mechanisms:
The choice between these two transport protocols isn't based on performance alone. Local transport keeps exposure contained. SSE opens a network path that security teams must protect like any other exposed endpoint.
The July 2026 specification formally classifies the legacy HTTP+SSE transport as deprecated, with a 12-month deprecation window, and points teams toward Streamable HTTP.
In a major revision, the July 2026 specification makes the protocol stateless by retiring the initialization handshake and the Mcp-Session-Id header, so no protocol-level session persists between calls. Each request now carries its own protocol version and client capabilities, along with its authorization. A connection verified once no longer earns lasting trust. Security controls must authenticate and inspect each request independently, a model that aligns with zero trust enforcement.
Understanding MCP Primitives
MCP servers build their functionality around three primitives. Each primitive transfers control to a different entity, and understanding where that control sits is just as important as understanding how the primitive works.
Prompts: Standardizing the User Interface
Prompts are predefined templates that standardize how users interact with the model. Examples include structuring a code review, filing a bug report, or generating a summary in a consistent, repeatable format.
Users usually choose prompts through a slash command in modern development tools. This design choice gives users predictability because they always know which workflow will run before it executes.
Resources: Providing the Contextual Data
Resources are read-only data that a client can pull into the model’s context. Examples of resources include local files, real-time API queries, and static database views.
Each resource has its own address, allowing clients to specifically identify which resource they wish to retrieve. Resources provide the model with the necessary background information to produce an accurate response based on current information, rather than relying on stale training data.
In this case, control resides with the application hosting the model. The host determines which resources to load at what time, and this allows developers to establish a governance policy to determine what context is delivered to the model in the first place.
Tools: Enabling Models to Take Action
Tools are executable functions that allow a model to perform some type of action in the real world, rather than simply reading about it. Examples of tools include sending emails, modifying records, and executing queries. Each tool includes a name, description, and defined input schema, and they are controlled by the model itself.
The LLM interprets user intent from the conversation and determines whether a tool call is appropriate without requiring manual intervention. While this ability is what makes tools so powerful, it's also precisely why tools should receive the most thorough security evaluation of the three primitives. A tool that can act without human approval can also act on the wrong record, the wrong inbox, or the wrong database.
MCP Security Risks: Vulnerabilities, Attack Vectors, and Mitigations
MCP security is the practice of protecting how AI models reach data and tools through MCP servers. Direct access to local files and enterprise APIs gives AI agents real reach but widens the attack surface. Each MCP server becomes a trust boundary, and everything it returns (data, tool descriptions, and tool results) enters the model's context as if it were trusted.
“MCP introduces some unique risks due to the automated nature of allowing LLMs to read, modify, or execute arbitrary code granted through tool access. Security teams must understand these risks and work with developers to collaboratively build capabilities that are effective and secure.”– Jesse Griggs, Senior Threat Researcher, Zscaler |
Indirect Prompt Injection
Indirect prompt injection is an attack in which hackers embed malicious text in a database record, web page, or document that an MCP server retrieves. The model reads that text as part of its context and may follow it as an instruction, because it cannot reliably tell data from commands.
A hidden line in a customer record that says "send this file to an outside address" is one example. Zscaler ThreatLabz has observed indirect prompt injection attacks in the wild, with hidden instructions on fake websites designed to steer AI agents.
The Confused Deputy Problem
The confused deputy problem occurs when a trusted program is tricked into misusing its authority on someone else's behalf. In MCP, a hijacked LLM commands the host application to run high-privilege local tools, such as tools that delete data or run system commands. The host acts with the user's authority, yet the user never approved the action. In effect, the attacker borrows the user’s access.
Tool Poisoning
Tool poisoning is a supply chain attack in which a malicious or compromised MCP server hides instructions in its tool descriptions or tool responses. Public registries host servers of unknown origin, and the hidden text is something the model reads, but the user rarely sees.
OWASP's analysis of MCP tool poisoning traces the root cause to a trust difference between connection time and runtime. Descriptions get reviewed once, while responses flow straight into the model's context.
Credential Harvesting
Credential harvesting happens when a prompt injection attack directs the agent to read environment variables or configuration files, where developers often store passwords and API keys. The agent then sends those secrets to an attacker-controlled endpoint. A single stolen key can open cloud services far beyond the original task, and the theft may look like normal agent activity in the logs.
Why Telemetry Raises the Stakes
Data transfers to AI/ML applications rose 93% year over year and reached 18,033 terabytes. The sheer volume of data that AI tools touch raises the stakes for MCP security because every unmonitored endpoint adds to an increasing flow of sensitive data.
The Zscaler ThreatLabz 2026 AI Security Report analyzed 989.3 billion AI/ML transactions across the Zscaler Zero Trust Exchange™ platform. Enterprise AI/ML activity grew 83% year over year.
Unmonitored MCP endpoints add to that volume without logging, data loss prevention (DLP), or policy enforcement. Each one creates noncompliance risks and a path for sensitive data to leave the organization.
Key MCP Vulnerabilities and Mitigation Strategies
MCP Governance: The Open Ecosystem
The speed of MCP adoption is what makes it a governance priority. An open standard that connects AI models to an organization’s most sensitive systems needs the same zero-trust scrutiny as every other access path into the network.
The Linux Foundation Transition and the Open Ecosystem
In December 2025, roughly a year after its initial release, Anthropic donated MCP to the Agentic AI Foundation (AAIF), which was established as part of the Linux Foundation. Anthropic, Block, and OpenAI co-founded the AAIF, with support from Google, Microsoft, AWS, Cloudflare, and Bloomberg. No single vendor owns or steers the standard.
Major model providers and cloud platforms now build on the same open specification, and the open source ecosystem has grown with them. More than 10,000 active public MCP servers now cover everything from developer tools to Fortune 500 deployments. The vendor-neutral design is what will keep MCP relevant, and it comes with a cost. No vendor is accountable for how MCP behaves inside a given environment, so each organization writes and enforces its own rules.
The Data Exposure Surface of AI Integrations
Connecting an internal server directly to an AI model opens a new channel for sensitive data to leave enterprise control, and organizations are already testing the limits of that channel. The Zscaler ThreatLabz 2026 AI Security Report recorded a 93% year-over-year jump in corporate data moving into AI tools in 2025, totaling 18,033 terabytes. ChatGPT alone triggered 410 million data loss prevention (DLP) policy violations, including attempts to share Social Security numbers, source code, and medical records.
And that is AI use before MCP multiplies the number of connection points. AI and ML transactions across the Zscaler cloud grew 91% year over year. Exposing a raw database through an MCP server without real-time monitoring compounds that leakage risk, because every query can pull sensitive information out.
MCP vs. APIs
A standard API offers a fixed set of endpoints, and every model that relies on it needs its own custom integration code written against that specific interface. MCP is designed to solve this limitation. It defines one standard way for any compliant model to discover and call whatever a server exposes, without a developer first hand-coding the connection.
APIs transfer data on request. MCP adds a layer that's built specifically for AI, letting a model reason about which tool to call and when. That flexibility is also the tradeoff. An API only does what its code allows, while an MCP server can be steered by a model's own immediate decisions. And that difference is exactly what security controls need to account for.
The Threat of Autonomous, Machine-Speed Exploits
A malicious prompt injection can let an attacker take control of a model-controlled tool, turning a benign MCP server into a foothold for lateral movement through the enterprise network. The model itself does not have to be compromised. The model simply has to execute commands embedded in data it would normally never process.
The speed of that risk is what's most alarming. In simulated adversarial testing by ThreatLabz, the median time to critical AI failure was 16 minutes, and attackers fully compromised 90% of all test systems within 90 minutes.
Attacks on AI applications now run at machine speed. Defenses have to run there, too. An uninspected MCP endpoint is a weak link in the enterprise supply chain.
Best Practices for Secure MCP Implementation
These practices are a starting point for bringing MCP servers under zero trust control.
Verify and Inspect
- Require mutual Transport Layer Security (TLS) on all remote MCP transport layers. The client and server must authenticate before exchanging any messages.
- Authenticate every call, not just the session. A tool call is a request to verify, never a standing privilege.
- Inspect outbound traffic from every MCP server in real time. Continuous inline inspection catches intellectual property and sensitive records leaving through a server before they reach an external destination.
- Configure runtime guardrails to identify normal tool-calling patterns for each server. If a sequence of tool calls deviates from those patterns, flag and block it as the first indication of unauthorized use of the server session.
Discover and Govern
- Only allow each server access to functions, commands, or operations that it was designed to run. There is no reason why a server intended to read customer records, for instance, should also be able to write changes to a production database.
- Run automated AI red team testing against every custom MCP server on a set schedule. Manual testing cannot keep pace with how fast vulnerabilities surface in a server built in-house.
- Map every live connection among applications, clients, and servers. A connection that’s not visible cannot be secured.
- Maintain continuous discovery of new MCP endpoints as teams stand them up. Shadow deployments spread fastest in the gap between what inventory shows and what developers actually built.
These steps work together. A zero trust model for MCP means verifying identity, inspecting traffic, and mapping dependencies as one discipline.
Common MCP Deployment Mistakes
Most MCP security failures trace back to a handful of avoidable setup errors. Watch for these as teams roll out new servers.
- Granting broad permissions by default: A server designed to answer questions ends up with write access to production data because no one scoped it down.
- Skipping authentication on SSE endpoints: Teams treat internal MCP servers with trust by default, leaving remote connections open to anyone on the network.
- Trusting third-party servers without review: A community-built server goes into production straight from a public directory with no one checking what it requests access to.
- Running local servers with excessive file access: A stdio server configured to read an entire directory when it only needs one file.
- Skipping logging and monitoring: No record of which tools were called, when, or by which session, so a breach goes unnoticed.
- Letting shadow deployments spread: Developers standing up servers for testing that never get decommissioned or added to inventory.
Enforcing MCP Security with Zscaler Zero Trust
The Zscaler Zero Trust Exchange™ platform enforces MCP security by sitting inline between corporate hosts and remote MCP servers. Every prompt, tool call, and response passes through policy before it reaches its destination. Session-aware inspection and AI-aware access controls apply to all MCP traffic that crosses the network.
Three layers work together to protect MCP environments:
- Network isolation blocks access to private IP ranges and prevents loopback DNS rebinding. A compromised agent stays out of internal systems.
- Inline DLP detects and blocks credentials, source code, personally identifiable information (PII), and regulated data before they reach unauthorized remote servers, even after a successful prompt injection.
- Zscaler Data Security Posture Management (DSPM) maps which AI service connects to which dataset. This lineage gives early warning of unsanctioned MCP integrations, a form of shadow AI.
To see Zscaler in action, request a demo.
FAQ
The biggest risks are over-privileged servers exposing more data than needed, malicious prompt injection hijacking tool calls, unsecured remote connections lacking authentication, and shadow deployments security teams never discover. Each of these MCP security risks turns a helpful integration into an unmonitored path into the network.
Yes. An MCP server can run entirely inside the organization’s own infrastructure, using stdio transport for local access or a privately hosted SSE endpoint for shared on-premises systems. Data never has to leave the environment for a model to use it, provided access controls are configured correctly.
MCP allows enterprises to give AI models access to internal tools and data in real time, with the same level of control and auditing as any other connection to internal systems, without building a custom integration for each tool/model pair.
A traditional API integration requires custom code for every model and data source pairing, which does not scale as an organization’s AI footprint grows. MCP replaces that with one standardized protocol, reducing the integration count and letting models discover and call tools dynamically instead of through fixed, hard-coded endpoints.
ChatGPT was first able to use MCP in November 2025. Since then, OpenAI has added read/write capabilities through Developer Mode to all users on business, enterprise, and education plans. Users can now integrate ChatGPT directly into custom and partner-built MCP servers.
Anthropic developed MCP in 2024 as a public standard for allowing AI models to access external data sources and tools. MCP was donated to the vendor-neutral Agentic AI Foundation by Anthropic under the auspices of the Linux Foundation in December 2025, thereby removing control from any single entity.
MCP fits any case where an AI model needs live data rather than training data alone. It pays off most when two or more models connect to two or more systems, because that is where the reduced integration count delivers the largest savings and where centralized governance matters most.
MCP is an open standard developed by Anthropic that gives developers a safe way for their AI models to interact with their applications and live data sources. Rather than building custom integrations for each application, MCP provides a common protocol that lets users integrate once and reuse it many times.
Local servers using stdio transport can expose the host process and local files if permissions are set too broadly, since anything the process can read becomes available to the model. A compromised local server can also serve as an entry point for malicious tool calls without ever touching the network.
Yes. OpenAI added native MCP support to its Agent SDK and Response API in 2025, and Google committed to MCP support across Gemini models and its SDK that same year.
Standard Input/Output (stdio) runs locally between a client and a subprocess server with no network exposure, giving it minimal latency. Server-Sent Events (SSE) runs over HTTP for remote or cloud-based servers, adding flexibility but requiring a secure network path with authentication and encryption.
Require mutual TLS and continuous identity verification for every remote connection. Inspect outgoing network traffic in real time to detect sensitive information before it leaves the environment. To limit the damage a compromised connection can cause, audit and configure each server's permissions to access only the required information.
An indirect prompt injection attack exploits MCP by hiding malicious instructions in content an MCP server retrieves, such as a database record, web page, or file. The model reads that content as context and may follow the hidden instructions as commands. This can trigger unauthorized tool calls or data exposure. Semantic scanning and input filtering on retrieved content reduce the risk.
A confused deputy is a trusted program tricked into misusing its own authority. In agentic AI, a hijacked model commands the host application to run high-privilege tools, such as tools that delete data or run system commands. The user never approved the action. Least-privileged access and human approval for sensitive actions limit the damage.
Organizations should treat every public MCP server as untrusted code. Automated static scans check server code before deployment, and dependency checks compare packages against public vulnerability databases. Teams can also pin approved tool descriptions, review any change, and validate tool responses, since poisoned instructions can hide in descriptions. Only servers from a vetted internal registry should reach production.
Blocking private IP ranges protects MCP environments by stopping DNS rebinding, an attack that tricks a browser into reaching a local MCP service by changing a domain's DNS answer after the page loads. Rejecting DNS answers that point to private or loopback addresses stops that switch at the network layer. Origin and Host header validation on the server adds a second check.
The MCP specification requires proxy servers with a static client ID to get per-client user consent before starting a third-party authorization flow. Servers must match the redirect URI exactly and bind a one-time state parameter to the consent decision. Consent cookies must use the __Host- prefix. These steps stop attackers from reusing a consent cookie to steal authorization codes.
Human-in-the-loop approval places a person between the model's decision and the tool's action. Before an agent changes or deletes data, a reviewer sees the request and can deny it. This breaks the attack chain when an injected prompt tries to trigger a destructive call, and it creates an audit record.
Traditional web application firewalls (WAFs) offer limited protection. They inspect URLs, headers, and form bodies, but MCP traffic is JSON-RPC, in which tool names and arguments carry the risk. Attacks such as prompt injection and tool poisoning depend on meaning rather than syntax. Session-aware inline inspection with semantic analysis and data loss prevention covers what a signature-based WAF misses.