The Model Context Protocol (MCP) is an open standard that defines how AI applications — Claude, Cursor, ChatGPT, autonomous agents — connect to external tools and data sources. The architecture is deliberately simple: a host (the AI app) talks to servers (small programs exposing tools, data, or prompts), and the model decides what to call but never talks to a server directly. The host mediates everything. The transport layer uses JSON-RPC over stdin/stdout or a single HTTP endpoint, but MCP is not just JSON-RPC. The protocol defines what goes inside the envelope: method definitions, capability negotiation, transports, and authentication. Servers can talk back, which distinguishes this from a simple request-response API. The bidirectionality matters — it allows servers to push updates, cancel operations, and negotiate capabilities dynamically. The core design choice is separation of concerns. The model reasons about what tools exist and when to use them. The host handles the actual invocation. The server exposes capabilities. No component reaches across its boundary. This is a deliberate architectural firewall: the model never has direct network access to tool servers, which constrains the attack surface and keeps the host in control of what actually executes. The generative case is strong. If MCP achieves broad adoption as a genuine open standard, it collapses the integration cost for every new AI tool. Today, each AI app builds bespoke connectors to each data source. MCP replaces N×M integrations with N+M — the same economics that made USB displace proprietary chargers. Any server written once works with any compliant host. This is real value creation, not redistribution. The risk is capture. Open standards have a well-documented lifecycle: emerge from one dominant player, attract ecosystem investment, then get subtly steered to favor the originator. MCP was created by Anthropic. The protocol is open, but the reference implementations, the developer mindshare, and the canonical tooling all flow through one company's ecosystem first. If Anthropic extends the spec faster than competitors can follow, openness becomes a moat dressed as a commons. The efficiency gains are concrete but early. Capability negotiation means servers declare what they can do, and hosts only surface relevant tools to the model. This reduces wasted context window and hallucinated tool calls. But the friction cost of adoption is real: every existing tool integration needs rewriting, server authors need to learn a new protocol, and the auth story is still maturing. Twenty years out, MCP either becomes the invisible plumbing layer (like HTTP) that everyone builds on without thinking, or it fragments into competing forks as major players refuse to cede control of their tool ecosystems. The determining factor is whether governance stays genuinely multi-stakeholder or remains Anthropic-adjacent.
