- MCP turns N×M bespoke AI integrations into N+M reusable connectors, the same standardization move ODBC and the Language Server Protocol made for their domains.
- The protocol is small: JSON-RPC 2.0 on the wire, three primitives (tools, resources, prompts), two transports, and OAuth 2.1-based authorization for remote servers. Since the 2026-07-28 revision the core is stateless, so a remote server scales like any other HTTP API.
- Adopt it deliberately: pilot read-only, put a gateway and an internal registry in front of every server, and gate write actions behind human approval.
The N×M integration problem
Before MCP, every AI application that needed enterprise context solved the same problem from scratch. A chat assistant that reads tickets, an IDE agent that queries the data warehouse, a support copilot that touches the CRM: each pairing meant a bespoke connector with its own auth handling, its own data shapes, its own failure modes. With N applications and M systems, you were on a path toward N×M integrations, each one owned by whichever team shipped it first and maintained by nobody in particular.
The Model Context Protocol attacks the multiplication itself. It standardizes the interface between AI applications and external systems, so each application implements the protocol once and each system exposes one server. N×M collapses to N+M. This is the same move ODBC made for databases and the Language Server Protocol made for editor tooling: agree on the wire contract, and clients and servers can be built independently and composed freely. Neither ODBC nor LSP was the most elegant possible design; both won because they were good enough, open, and adopted early by the tools that mattered. MCP is following the same trajectory.
Anthropic announced MCP as an open protocol in November 2024, and in December 2025 donated it to the Agentic AI Foundation, a Linux Foundation fund co-founded with OpenAI and Block, which made its governance formally vendor-neutral. It has been adopted broadly across major AI vendors and developer tools, and it is the closest thing the industry has to a default integration layer for agentic applications. For an enterprise architect the appeal is plainly economic: a connector built once for a chat surface can be reused by IDE assistants and by agent workloads without rework, and the security review you invest in that connector amortizes across every surface that uses it.
The rest of this article covers what the specification actually says, where the trust boundaries sit, and how to adopt MCP with the discipline you would apply to any new class of production API.
Protocol anatomy: hosts, clients, servers
MCP defines three roles. The host is the AI application the user actually touches: a chat product, an IDE, an agent runtime. The host embeds one or more MCP clients, and the spec is strict about cardinality: each client talks to exactly one MCP server. A host talking to five servers runs five clients. The server is the adapter in front of a capability: a filesystem, a ticketing system, a warehouse, an internal API.
All traffic between client and server is JSON-RPC 2.0: requests that expect responses, notifications that do not, and results or errors. There is no bespoke framing to learn; if your teams have ever debugged LSP traffic, MCP messages will look immediately familiar.
+---------------------- Host application ----------------------+
| chat app, IDE, or agent runtime |
| |
| +--------------+ +--------------+ +--------------+ |
| | MCP client A | | MCP client B | | MCP client C | |
| +------+-------+ +------+-------+ +------+-------+ |
+---------|-----------------|-----------------|----------------+
| JSON-RPC 2.0 | |
v v v
+--------------+ +--------------+ +--------------+
| MCP server: | | MCP server: | | MCP server: |
| filesystem | | ticketing | | warehouse |
| stdio, local | | HTTP, remote | | HTTP, remote |
+--------------+ +--------------+ +--------------+
Discovery is explicit. Every request declares its protocol version, and the client learns a server's surface by asking: an optional server/discover call returns its capabilities, and the list calls enumerate its tools, resources and prompts. Nothing is assumed: a client must not invoke a capability the server never declared. For an architect, explicit discovery is the useful hook. It makes a server's entire surface area enumerable on demand, and anything enumerable can be logged, diffed and reviewed.
The three primitives: tools, resources, prompts
Everything an MCP server exposes falls into three primitives, and the specification is deliberate about who controls each one.
Tools are model-controlled: executable actions the model chooses to invoke mid-conversation, each described by a name, a natural-language description and a JSON Schema contract for its inputs. The invocation mechanics are the same tool-calling loop used elsewhere in the stack (see tool calling mechanics); what MCP adds is a standard way to discover and call tools across any server. Resources are application-controlled: URI-addressed context, such as a file, a record or a document, that the host application decides to place into the model's context. Prompts are user-controlled: named templates a person explicitly selects, typically surfaced as slash commands or menu entries.
| Primitive | Controlled by | Triggered when | Illustrative example |
|---|---|---|---|
tools | The model | Model decides during a task | create_ticket with schema-validated arguments |
resources | The host application | App attaches context | tickets://PROJ-42 issue body |
prompts | The user | Explicit human selection | A summarize-incident template |
The control axis is the security design point, not an implementation detail. A model-controlled primitive can be triggered by anything that influences the model, including text retrieved from outside your trust boundary, so tools need schema validation, least-privilege credentials and, for anything that writes, approval gates. Resources are safer by construction because the application chooses them, yet they still carry data into context and can smuggle in injected instructions. Prompts are the calmest of the three because a human is in the loop by definition. Build your review process around this asymmetry rather than treating "an MCP server" as one undifferentiated risk category.
Transports and the stateless core
The specification defines two transports. stdio runs the server as a local subprocess of the host, exchanging JSON-RPC over standard input and output. It is the natural fit for developer-machine capabilities: filesystem access, local git, build tooling. Streamable HTTP is the remote transport: the client sends JSON-RPC over HTTP and the server can stream its response back. Remote transport is what makes shared, centrally operated servers possible, and it is the transport that matters for enterprise deployments. The older HTTP plus server-sent-events transport is deprecated.
The 2026-07-28 revision, the largest since launch, changed what happens on that wire. Earlier revisions were stateful: a client opened a session with an initialize handshake, the server tracked it under an Mcp-Session-Id header, and the server could push its own requests back to the client over held-open streams. That design suits a desktop app talking to a local subprocess. It is awkward for an enterprise running remote servers behind load balancers, because every replica needs shared session storage and every long-lived stream is a connection to babysit. The new core is plain request and response:
| Before (2025 revisions) | Since 2026-07-28 | Why an architect cares |
|---|---|---|
Initialize handshake and Mcp-Session-Id | Every request carries protocol version, client identity and capabilities | Servers scale horizontally like any HTTP API; no sticky sessions or shared session store |
| Server-initiated sampling, elicitation and roots requests | Multi Round-Trip Requests: the server answers input_required, the client retries with the answers attached | Mid-call user input survives gateways, retries and restarts |
| Routing meant parsing JSON bodies | Mcp-Method and Mcp-Name headers on every request | Gateways, firewalls and rate limiters can authorize and meter per tool |
| Catalogs re-fetched on every connection | List results carry ttlMs and cacheScope | Clients and gateways cache tool catalogs safely |
| Tasks experimental in the core | Tasks moved to a formal extension, polled with tasks/get | Long-running jobs get an explicit, optional contract |
Deprecated features get a minimum twelve-month off-ramp: roots, sampling and logging, plus the legacy transport. The four Tier 1 SDKs (TypeScript, Python, Go, C#) supported the revision at release, and the major cloud and tooling vendors committed to it on day one. The same release introduced a formal extensions framework, so capabilities such as MCP Apps and enterprise-managed authorization can evolve outside the core. Two consequences follow. New servers should target 2026-07-28 from the start. Existing servers that lean on session state or server-initiated requests need a migration plan inside the deprecation window, and it is a refactor, not a recompile.
The two transports carry sharply different trust assumptions, and conflating them is a common early mistake. A stdio server is code running with the user's local privileges; installing one is a software supply-chain decision, so it belongs under the same allowlisting and provenance controls as any other locally installed executable. A remote HTTP server is a network service: it must authenticate callers, authorize per-user, rate-limit, and log, and it can be placed behind your existing network controls. As a rule, prefer remote servers for anything shared or sensitive, and treat local stdio servers as developer tooling with an explicit approval path.
Authorization and the MCP threat model
For remote HTTP servers, the specification defines an OAuth 2.1-based authorization model: the MCP server acts as a resource server, access tokens are issued by an authorization server the deployer controls, and clients discover the authorization endpoints through protocol metadata. The details have been refined across spec revisions, so pin your implementation to a specific protocol version and track changes deliberately. The 2026-07-28 revision shows why: it requires clients to validate the authorization server's issuer before redeeming a code, binds client credentials to the server that issued them, and formally deprecates Dynamic Client Registration in favor of Client ID Metadata Documents, where a client identifies itself with a URL pointing at its published metadata. That is welcome news for an enterprise: client identities become stable URLs you can allowlist, instead of a sprawl of auto-registered clients nobody owns. Just as important is what the spec leaves out: it governs how clients authorize to the MCP server, and says nothing about how the server authenticates to the systems behind it. Downstream credential scoping stays entirely with the deployer, and that is where most real risk concentrates. An over-scoped service account sitting behind a beautifully secured MCP endpoint is still an over-scoped service account.
The threat model has four recurring shapes. Tool poisoning: a malicious or compromised server ships tool descriptions crafted to steer model behavior. Prompt injection via tool results: data returned by a legitimate tool contains instructions the model then follows. Confused deputy: a server or gateway exercises its own broad authority on behalf of an attacker-influenced request. Over-broad scopes: connectors granted admin-level access because narrow scopes were inconvenient to provision.
The mitigations are unglamorous and effective: least-privilege credentials per server, per-user credential pass-through instead of shared service accounts where feasible, human approval on consequential actions, egress restrictions on server workloads, and a log line for every tool call with its arguments and results. The broader containment patterns are covered in guardrails and sandboxing.
Enterprise patterns: gateways, registries, governance
The pattern that separates production deployments from pilots is a central MCP gateway: a service that terminates client connections, enforces authentication and authorization against your identity provider, applies rate limits, and emits audit logs, before proxying traffic to backend servers. It plays the same role for connectors that a model gateway plays for inference: one choke point where policy is enforced consistently, so individual server teams do not each reimplement auth and logging, and security gets a single place to look. The stateless core makes the gateway cheaper to run: routing headers let it authorize and meter each tool call without parsing payloads, cacheable list results cut catalog chatter, and without sticky sessions it scales like any other stateless service.
The second pattern is an internal server registry: a catalog of approved servers with an owner, declared scopes, data classification, and review status for each entry. New servers enter through a review process that checks credential scoping, tool descriptions and injection handling before listing. The registry turns "can I use this connector?" from a Slack thread into a lookup, and it is the mechanism that stops teams from installing arbitrary community servers against production data.
The payoff arrives as connector reuse. The same ticketing server should serve your chat assistant, your IDE integration and your autonomous agents; if it does not, you have standardized the protocol without capturing the economics. Reuse across surfaces is the metric that justifies the gateway and registry investment.
None of this is exotic. It is API management, applied to a new class of API whose consumer happens to be a language model.
A 90-day adoption playbook
Treat MCP as a platform capability with a deliberate rollout, not a hackathon artifact that escapes into production. A 90-day arc is realistic for a first wave.
- Days 0 to 30: prove the plumbing, read-only. Stand up one server, built on the 2026-07-28 revision, against a low-risk system: an internal knowledge base or ticket search is ideal. Expose only read tools and resources, wire it into a single host surface, and measure answer quality, latency and failure modes. Resist the urge to add write actions; the goal is operational confidence, not capability.
- Days 30 to 60: writes behind approvals, gateway online. Add the first write-capable tools, every one gated by human approval in the host. Stand up the gateway with identity-based access and full call logging, define the downstream credential scoping model, and move the pilot server behind it.
- Days 60 to 90: institutionalize. Launch the registry with an ownership model and a security review checklist covering scopes, data classification, tool description review and injection testing. Publish a paved-road server template and developer enablement docs, then onboard a second and third server to prove the review process scales.
Measure connector reuse above all else: the number of distinct surfaces consuming each server. If every new AI project still builds bespoke integrations after the quarter, you have deployed a protocol without changing your economics. Secondary metrics worth tracking are approval rejection rates on write actions (a proxy for how well-scoped your tools are), tool error rates, and elapsed time to onboard a new server through review.
MCP is small enough to read in an afternoon and consequential enough to reorganize how integration work is owned. The durable win is not the protocol itself; it is that standardization lets you centralize authorization, audit and review in one place. To see the moving parts live, the Agent Studio in the Lab runs agents against real tool servers.