What is the Model Context Protocol (MCP), in plain English?
Plain-English definition · Updated 2026-11-12. Every claim below is attributed to the organisation that published it — the MCP specification at modelcontextprotocol.io, Anthropic's donation announcement, and Anthropic's engineering blog. MCP's wire format changed materially in July 2026, so advice written before then should be treated as a different protocol.
AITop is an independent guide. Prices and features change fast — always check the vendor's page.
The Model Context Protocol (MCP) is an open protocol — JSON-RPC 2.0 messages over either a local subprocess (stdio) or HTTP (Streamable HTTP) — that standardises how an AI application discovers and calls tools on a separate server, so one integration works across ChatGPT, Claude, Gemini, Cursor, Copilot and VS Code instead of one integration per pair. Anthropic introduced it in November 2024 and donated it to the Agentic AI Foundation, a directed fund under the Linux Foundation, on 2025-12-09; by then it had 10,000+ active public servers and 97M+ monthly SDK downloads. The part almost nobody has updated: the current specification, dated 2026-07-28, deleted protocol-level sessions and the initialize handshake, so every request now carries its own protocol version and capabilities and the protocol is stateless. It also added a required server/discover call, replaced server-initiated requests with a multi-round-trip pattern, and deprecated Roots, Sampling and Logging. For a buyer, "MCP support" is therefore a compatibility claim rather than a feature: what matters is which revision, which transport, and who holds the OAuth token.
What does MCP actually mean?
MCP is a wire standard, not a product and not a plugin store. Its specification defines three roles — a host (the AI application), a client (the connector inside the host, one per server), and a server (the service that exposes capabilities) — and one message format. The specification's own framing is that MCP "provides a standardized way for applications to share contextual information with language models, expose tools and capabilities to AI systems, and build composable integrations and workflows," using "JSON-RPC 2.0 messages" between those three roles. It is explicitly modelled on the Language Server Protocol, which did the same job for editors and programming languages.
Servers expose three kinds of thing, and the distinction is the one buyers most often miss. Tools are functions the model may execute — the only primitive that can change the world. Resources are context and data for the user or the model to read. Prompts are templated messages and workflows for a human to invoke. Clients may offer one thing back: elicitation, a structured way for a server to ask the user for more information. Everything else in the protocol is plumbing — progress, cancellation, error reporting, configuration.
Two transports carry those messages. stdio is newline-delimited JSON-RPC over the standard streams of a subprocess the client launches; it is how a desktop app runs a local server. Streamable HTTP is "each message is an HTTP POST to a single MCP endpoint; replies arrive as a JSON object or a request-scoped SSE stream" — it is how a remote server behind a URL works. That difference is not cosmetic: a local stdio server inherits your machine's credentials and has no authentication story of its own, while a remote server needs OAuth, scopes and a resource identifier. Same protocol, two completely different security models, and vendors routinely advertise the first while selling the second.
Why does MCP change which tool you buy?
Because it moves the integration from the vendor's roadmap to a spec anyone can implement, and that inverts what you are evaluating. Before MCP, every AI product connected to your data through bespoke, vendor-owned connectors; the catalogue was the moat, and switching cost was the catalogue. With MCP, the catalogue is portable — Anthropic's donation post lists first-class support across ChatGPT, Cursor, Gemini, Microsoft Copilot and Visual Studio Code, and states that enterprise deployment support exists from AWS, Cloudflare, Google Cloud and Microsoft Azure. The connector is no longer the reason to pick a product; the quality of the agent loop around it is.
What replaces it as a differentiator is cost and control, and both are measurable. Cost: tool definitions are injected into the prompt and billed as input tokens on every request. Anthropic's engineering team published the number that makes this concrete — a workflow that consumed 150,000 tokens of tool definitions and intermediate results ran in about 2,000 tokens when the agent wrote code against the tools instead of calling them one at a time, "a time and cost saving of 98.7%." The same post estimates that a two-hour sales meeting passed between two tools costs "an additional 50,000 tokens," and that a 10,000-row spreadsheet can be reduced to five rows before it reaches the model. A connector catalogue is a recurring charge, not a one-off setup fee.
Control: every server you connect is a leg of the prompt-injection trifecta. The specification is unusually direct about this for a standards document — "Tools represent arbitrary code execution and must be treated with appropriate caution," and tool descriptions "such as annotations should be considered untrusted, unless obtained from a trusted server." A protocol that lets a user mix servers from many sources is, by construction, a protocol that lets a user assemble an agent that reads untrusted content, holds private data and can send things out. That is why prompt injection is the entry to read next: MCP is the mechanism, not the mitigation.
What changed in 2026?
Is MCP still a session protocol?
No, and this is the change that invalidates most published advice. The 2026-07-28 revision lists as its first two major changes: "Remove protocol-level sessions and the Mcp-Session-Id header from the Streamable HTTP transport," and "Make MCP stateless: remove the initialize/notifications/initialized handshake. Every request now carries its protocol version and client capabilities in _meta." The base protocol section now reads "Stateless, self-contained requests" and "Per-request capability negotiation." A server that needs state across calls must mint its own handle and pass it as an ordinary tool argument.
Three consequences follow, and each one is a procurement question. Servers must implement a server/discover RPC that advertises supported protocol versions, capabilities and identity — so "does your server answer server/discover?" is a one-line test of whether a vendor is on the current spec. Version mismatches return UnsupportedProtocolVersionError, which means a client and server built a year apart may simply refuse each other. And servers may no longer initiate JSON-RPC requests: the transport page states flatly that "servers do not initiate JSON-RPC requests and clients do not send JSON-RPC responses," with the old patterns replaced by a Multi Round-Trip Request flow in which a server returns resultType: "input_required" and the client retries with the answers.
Which revision should you actually require?
Ask for the revision string and treat 2026-07-28 as current, 2025-11-25 as the previous one, and anything earlier as legacy. The 2025-11-25 revision is the one that introduced experimental tasks, incremental scope consent and Client ID Metadata Documents; 2026-07-28 moved tasks into an official extension, replaced ping, logging/setLevel and resources/subscribe with per-request settings and a single subscriptions/listen stream, dropped SSE resumability entirely ("A broken response stream loses the in-flight request"), and deprecated the OAuth 2.0 Dynamic Client Registration flow in favour of Client ID Metadata Documents. It also deprecated three features outright — Roots, Sampling and Logging — with a minimum twelve-month deprecation window and a public registry. If a vendor's connector depends on Sampling, it is building on a feature the spec has already scheduled for removal.
Do the vendors describe it accurately?
Not always, and one example is worth knowing because it is checkable in two documents. Anthropic's donation announcement says "the November 25th spec release introduced many new features, including asynchronous operations, statelessness, server identity, and official extensions." The 2025-11-25 changelog does not list statelessness anywhere; the statelessness change is dated 2026-07-28, tied to two specification enhancement proposals. The likeliest reading is a marketing summary written ahead of the change it described. The lesson generalises: read the changelog, not the announcement — the changelog is versioned, dated, and cites the proposal that made each change.
The other 2026 development is governance. On 2025-12-09 Anthropic donated MCP to the Agentic AI Foundation (AAIF), "a directed fund under the Linux Foundation, co-founded by Anthropic, Block and OpenAI, with support from Google, Microsoft, Amazon Web Services (AWS), Cloudflare, and Bloomberg." MCP joined Block's goose and OpenAI's AGENTS.md as founding projects, and both Anthropic's post and the MCP project blog state that the maintainer structure and SEP process are unchanged. For a buyer this is the difference between adopting a competitor's protocol and adopting a neutral standard, and it is the single strongest argument that the interface will still exist when your three-year contract ends.
Quick checklist
- Ask for the revision string, not the checkbox. "MCP support" without a date is unfalsifiable. Current is
2026-07-28; anything that only speaksinitializeis running a protocol the spec has since removed. - Ask which transport you are buying. A bundled stdio server on your laptop and a hosted Streamable HTTP endpoint are different products with different auth, different uptime and different data-residency answers.
- Test
server/discoverbefore you trust the integration. It is mandatory in the current revision. A server that cannot answer it is either old or incomplete — and either way, your agent will hit the failure at runtime rather than at evaluation. - Count the catalogue in tokens, then in dollars. Add up every tool description your agent loads per request, multiply by requests per day, and price it as input tokens. Anthropic's own before/after is 150,000 → 2,000; the gap is the value of progressive disclosure.
- Map each server to the trifecta. For every connector, note whether it reads untrusted input, holds private data, or can act outward. Servers are additive: three individually reasonable connectors can compose into an unsafe agent.
- Ask who holds the token and where it is scoped. Remote MCP servers use OAuth; incremental scope consent and Client ID Metadata Documents are now the recommended patterns, and a connector that wants one broad scope for everything is telling you it has not implemented them.
Where you'll hit it
MCP is the reason "connectors" became a feature category rather than a partnership announcement, so it shows up in almost every purchase on this site. In the best AI coding assistants ranking it is the difference between an agent that can reach your issue tracker through a vendor-built integration and one that reaches it through a server you can swap. In Claude Code vs Cursor it is the part of the two products that is genuinely converging, which is why the comparison now turns on permissions and review flow rather than on tool lists. In Ollama vs LM Studio it is the dividing line for local-first setups: a local model is only as useful as the local servers it can drive. Related terms: function calling is the model-level mechanism MCP standardises at the protocol level, AI agent is the product category that consumes it, prompt injection is the attack surface it widens, and tokens per second explains why a large tool catalogue also costs latency, not just money. Full list on the AI tools glossary.
The bottom line
The Model Context Protocol is an open JSON-RPC 2.0 standard, introduced by Anthropic in November 2024 and donated to the Linux Foundation's Agentic AI Foundation on 2025-12-09, that lets one AI connector work across ChatGPT, Claude, Gemini, Cursor, Copilot and VS Code. Its current revision, 2026-07-28, is stateless: protocol sessions and the initialize handshake are gone, server/discover is mandatory, servers can no longer initiate requests, and Roots, Sampling and Logging are deprecated. That is why "we support MCP" is not an answer — the three questions that decide the purchase are which revision, which transport, and who holds the token. The cost of getting it wrong is measured in tokens: 150,000 versus 2,000 in Anthropic's own benchmark for the same task.