Skip to main content

Explainer

What Is the Model Context Protocol (MCP)? Inside the 2026-07-28 Spec That Drops the Handshake

By AInews Desk
What Is the Model Context Protocol (MCP)? Inside the 2026-07-28 Spec That Drops the Handshake
5 min read
979 words

For most of its life, the Model Context Protocol (MCP) worked like a phone call. A client connected, introduced itself once, and the server remembered who it was talking to. The latest revision ends that arrangement. The changelog says it will Make MCP stateless: remove the initialize/notifications/initialized handshake. This explainer covers what MCP is, what its servers expose, how messages travel, and why removing the handshake matters if you build or run MCP integrations.

What is the MCP protocol, in plain terms?

The official introduction defines MCP as an open-source standard for connecting AI applications to external systems. With it, AI applications such as Claude or ChatGPT can connect to data sources like local files and databases, tools like search engines and calculators, and workflows like specialized prompts.

The project describes MCP as a USB-C port for AI applications. The comparison works at one level: one shared connector replaces a drawer full of custom cables. It fits less well at another, because MCP is a set of message rules, not a physical plug. Those rules have just changed in a way that has no USB equivalent.

The project's own examples show what the standard is meant to do. Agents can access your Google Calendar and Notion. Claude Code can generate an entire web app using a Figma design. AI models can create 3D designs on Blender and print them out. On the client side, the introduction names Visual Studio Code, Cursor and MCPJam among the development tools that support it.

What does an MCP server actually expose?

MCP has a host, clients and servers. The host is the AI application, and it works by creating one MCP client for each MCP server; each client keeps a dedicated connection to its server. Visual Studio Code, for example, acts as a host and opens a separate client for every server it connects to.

Servers offer three core primitives: tools, resources and prompts. Tools are executable functions the AI application can invoke, such as file operations, API calls or database queries. Resources are data sources that provide context, such as file contents or database records. Prompts are reusable templates, such as system prompts or few-shot examples. Clients can offer a primitive too: elicitation lets a server ask the user for more information or for confirmation of an action.

Some features are on their way out. Sampling is deprecated as of protocol version 2026-07-28. The changelog also deprecates Roots and Logging, and says all three remain fully functional during the deprecation window, but new implementations should not add support for them.

Local versus remote: the two transports

MCP supports two transport mechanisms. Stdio uses standard input and output streams between local processes on the same machine, with no network overhead, and a local server like this typically serves a single client. Streamable HTTP uses HTTP POST for client-to-server messages, with optional Server-Sent Events for streaming. It is what lets a server run remotely and serve many clients, it supports bearer tokens, API keys and custom headers, and MCP recommends using OAuth to obtain authentication tokens.

The older HTTP+SSE transport, deprecated since protocol version 2025-03-26, has now been formally reclassified as Deprecated. Implementers are told to migrate to Streamable HTTP.

DateEventImpact
2025-03-26HTTP+SSE transport deprecated (modelcontextprotocol.io)Streamable HTTP becomes the path
2025-11-25 (modelcontextprotocol.io)includeContext values soft-deprecated (modelcontextprotocol.io)Soft-deprecated since 2025-11-25, reclassified as Deprecated (modelcontextprotocol.io)
2026-07-28 (modelcontextprotocol.io)Sessions removed (modelcontextprotocol.io)Each request stands alone
2026-07-28 (modelcontextprotocol.io)Roots, Sampling, Logging deprecated (modelcontextprotocol.io)Still work, but plan migrations

How the 2026-07-28 spec replaces the handshake

Think of the difference between a phone call and a stack of letters. A caller introduces themselves once. A letter writer puts a return address and letterhead on every envelope, so any clerk can handle any letter. Clients SHOULD identify themselves on each request, and servers should identify themselves in each result's _meta. If the versions don't match, the server returns UnsupportedProtocolVersionError.

Sessions are gone too. The spec removes protocol-level sessions and the Mcp-Session-Id header from the Streamable HTTP transport. A server that needs to remember something between calls now uses explicit, server-minted handles passed as ordinary tool arguments.

Without a handshake, clients need another way to learn what a server can do up front. That is the job of server/discover: servers MUST implement this RPC to advertise their supported protocol versions, capabilities, and identity. Clients may call it before anything else, or use it as a backward-compatibility probe on STDIO.

A long aisle of identical server racks in a data center, with cables from each rack running to one shared network switch.A long aisle of identical server racks in a data center, with cables from each rack running to one shared network switch.

What changes for your code

This revision changes behavior, not just wording. Every result now carries a required resultType field, either "complete" for ordinary results or "input_required" for multi round-trip interim results. Clients must treat results from older servers that leave the field out as complete. The spec also removes SSE stream resumability and message redelivery from Streamable HTTP.

For the deprecated features, the changelog gives a migration for each. Pass directories or files through tool parameters, resource URIs, or server configuration instead of Roots. Integrate directly with LLM provider APIs instead of Sampling. Log to stderr (stdio) or use OpenTelemetry instead of Logging.

What this means in practice: if you start a server today, design it around self-contained requests, implement server/discover from the beginning, and don't build on Sampling, Roots or Logging. If you maintain an existing server, the deprecation window gives you time to migrate, but the direction is clear. MCP requests no longer depend on remembered connection state.

Sources

5 min read
•
979 words

Tags

Model Context Protocol MCPMCP initialize handshake specificationwhat is MCP protocolModel Context Protocol spec

Related Articles