MCP Spec Overhaul: Why the Sudden Shift to 'Stateless'?

Anthropic's Model Context Protocol (MCP) is undergoing its most significant architectural change since launch. In the latest specification finalized today, July 28, 2026, it is completely stripping away complex connection sessions to transition to a stateless structure.

This update is driven by SEP-2567, which introduces a sessionless approach, and SEP-2575, which eliminates the tedious initial handshake process. The core of this change is to reduce complexity and minimize server overhead to maximize infrastructure scalability.

We will break down why agent developers worldwide are paying attention to this news and how it provides practical benefits to builders creating real-world products, in a simple and clear way.

The Exit of Complex Handshakes and Session IDs

Previously, every time an MCP server started a connection, it had to go through a complex 3-step handshake process involving 'initiation request, initiation response, and initialization complete notification.' Because it had to maintain a session ID every time, it often caused serious bottlenecks in large-scale enterprise infrastructure.

To solve this, two proposals were passed in the new spec finalized on July 28, 2026: SEP-2575, which removed the complex handshake steps, and SEP-2567, which eliminated cumbersome session IDs. Thanks to these changes, MCP servers can now exchange requests lightly whenever needed, just like standard web APIs.

Information like version details or client permissions is now dynamically included in the JSON-RPC meta field with every request. If you want to check which features a server supports in advance, you can easily explore them using the newly added server discovery method.

Where is State Management Handled Now?

If the session is gone entirely, how do we maintain the context or state of a conversation now?

If the old way was like booking a hotel room and holding onto a key card throughout your stay, the new way is like presenting a unique service ticket whenever you need something done. The conversation flow is maintained by passing explicit state handles, issued by the server, as tool arguments. As a result, the server is completely freed from the burden of having to hold onto and remember heavy connections with clients.

In addition, a metadata envelope is passed with every request. Specifically, starting with this spec, standard routing metadata called Mcp-Method and Mcp-Name must be included in the HTTP request headers. Thanks to this metadata, network equipment can quickly route requests to the desired server without having to inspect complex data one by one.

As a result, communication between agents and servers has become much more flexible. Even if the network drops suddenly, you can continue the conversation without interruption by simply handing over the previously obtained state handle, without complex recovery processes.

Why Infrastructure Scalability Just Got 10x Easier

If you have worked with server development or infrastructure at all, you know how annoying 'session synchronization' can be. Previously, to run multiple remote MCP servers to handle increased agent traffic, you needed special routing configurations to ensure a specific user's requests always went to the same server. But now, with the stateless structure, you can simply place servers randomly behind a standard load balancer.

This is because every request carries the necessary metadata, regardless of which server it lands on. Furthermore, you no longer have to worry if a connection drops due to network instability. With this update, the complex and difficult-to-manage SSE reconnection method has been cleanly removed.

In its place, a light and stable Task API has been added. You can now safely complete background tasks through independent task processing without complex stream recovery. It essentially opens the highway for enterprises to freely scale their AI agent tools without worrying about complex infrastructure costs.

AI Agents Evolving into Practical Infrastructure

This update is a crucial shift for MCP to move beyond an experimental tool and become distributed agent infrastructure that runs reliably in large-scale enterprise environments. By lifting the heavy burden of session management, developers can now design much lighter and easier-to-scale agent systems.

Moving forward, it will be worth watching how efficiently complex states are managed in client environments, and how development tools and libraries evolve to match the new stateless standard specifications. Keep an eye on how these lighter agent systems transform our real-world development productivity.