MCP dropped the handshake, and the plumbing went with it

The Model Context Protocol's July 28 release deletes the session. Where a tool call previously required a handshake to open a session and a second request to actually do the work, it is now one self-contained HTTP request that any server instance behind a plain load balancer can answer. The maintainers describe it as MCP "transforming from a bidirectional stateful protocol into a request/response stateless protocol," and it is the largest change to the standard since it launched.

Key facts

• The scale it is changing: MCP's official SDKs see close to half a billion downloads a month, with the TypeScript and Python SDKs each past a billion total.
• What went away: the initialize/initialized exchange and the Mcp-Session-Id header, replaced by per-request _meta and an optional server/discover call.
• When and who: July 28, 2026, announced by lead maintainers David Soria Parra and Den Delimarsky.
• Primary source: The 2026-07-28 Specification; Anthropic's rollout note covers Claude support.

MCP is the standard way to hand an AI agent a new capability - a database it can query, an API it can call, a service it can act on. Anthropic introduced it in late 2024, it became ubiquitous through 2025, and it acquired a reputation for being heavier to run than the job warranted. The reason was the session. Every client-server pair had to open a connection, negotiate, and keep that connection pinned to one particular backend machine for its lifetime, because the state lived in the transport.

That constraint cascades in unpleasant ways at any real scale. You cannot put an MCP server behind an ordinary round-robin load balancer, because the second request has to reach the same instance as the first. You cannot run it serverless. A client configured with five servers holds five live connections whether or not it ever uses them, and pays the initialization cost before it can do anything at all.

The new design makes every request self-describing. Protocol version, client identity, and capabilities ride along inside a _meta field on the request itself, so nothing needs to be remembered between calls. Method and tool names travel in Mcp-Method and Mcp-Name HTTP headers, which means a gateway can route and authorize a request by reading its headers rather than parsing the body. List responses now carry cache hints and a deterministic order, so a client can cache a server's tool catalog and keep prompt caches stable across reconnects.

The comparison is between a phone call and a letter. Under the old design, using a tool meant dialing, waiting for someone to pick up, establishing who you are, and only then asking your question - and staying on the line the whole time. Under the new one you write down everything the recipient needs and drop it in the post, and whichever clerk opens it can answer.

State did not become impossible, it became visible. The maintainers' guidance is that a server needing continuity across calls should hand out an explicit handle from one tool and have the model pass it back as an argument to the next. Their stated reason is interesting on its own terms: "We found this works better than session state hidden in the transport - the model can see the handle and thread it between tools." The thing the model can read, the model can reason about.

The other structural change is that server-to-client requests no longer need a held-open stream. When a server needs something back from the client mid-call - a sampling request, a prompt for user input - it now returns resultType: "input_required" and the client retries the original call with the answers attached. The release also hardens authorization, adding RFC 9207 issuer validation and shifting away from Dynamic Client Registration toward client metadata documents.

The clearest signal that this matters is who it brought back. Simon Willison, who had publicly written MCP off in favor of simply giving agents a terminal, called this "the most significant change to the MCP spec since it first launched" and said it "reignited my personal interest in the protocol." His reasoning is a security argument, not a convenience one: handing an agent a shell with internet access is risky and needs a strong model to drive it, whereas "MCP tools are easier to audit and control, and simple enough that smaller models that run on a laptop can still drive them reasonably well." He built and shipped mcp-explorer the same week, a stateless CLI for probing MCP servers - the sort of thing that only gets built when the barrier drops.

The honest caveat is compatibility, and it is not small. This is a breaking change to a protocol with an enormous installed base, and "supports MCP" no longer tells you enough - both ends have to agree on which revision they mean. The TypeScript SDK's migration guide is explicit that connecting still speaks the 2025 handshake unless you opt in, with an automatic mode that probes for the new discovery call and falls back. The guide also carries a warning worth heeding: the request state a server now receives from the client is untrusted input and should be integrity-protected, which is the same lesson role-confusion research keeps delivering about anything an agent reads. The protocol got much easier to run. The ecosystem still has a year of upgrade work in front of it, which is presumably why the release also introduces a twelve-month minimum deprecation window.

---

Originally published on Ground Truth, where every claim is checked against the primary source.