MCP just made its biggest change since remote servers arrived: it deleted sessions. The 2026-07-28 specification turns the Model Context Protocol from a bidirectional, stateful protocol into a stateless request/response one. No more initialize handshake, no more Mcp-Session-Id header, no more pinning a client to the instance holding its session. Any request can now land on any instance behind a plain round-robin load balancer.
That headline alone would be enough for a release note. But the same version smuggled in something quieter and arguably bigger: two required HTTP headers that let gateways route, throttle, and meter agent traffic without ever opening the request body. Agent traffic just became ordinary HTTP — and infrastructure teams just got their old toolbox back.
What changed: sessions are gone, headers carry the load
Early MCP transports started with an initialize/initialized exchange that established a session, tracked via Mcp-Session-Id. Every subsequent request had to find the state tied to that session. Auto-scaling infrastructure had to keep sessions alive, deploys had to drain or migrate them, and load balancing was effectively impossible because a client was pinned to the instance holding its session.
The new spec removes the handshake, the session header, and protocol-level sessions from the core request path. Each request now carries its protocol version, client identity, and capabilities in _meta. A client that wants capabilities up front can make an optional server/discover call, but nothing requires it. Requests are fully self-describing.
The less-noticed change: Streamable HTTP requests must now include Mcp-Method and Mcp-Name headers. A tool call arrives as Mcp-Method: tools/call and Mcp-Name: search, followed by the JSON-RPC payload. Gateways, rate limiters, and WAFs can read those headers and act per method or per tool, using the exact mechanisms they already run for every other API. Some implementers go further, copying tool arguments into headers for custom routing.
Governance moves into the transport layer
Until now, agent governance grew in a separate direction: Cloudflare's agent tracing and Azure API Management's AI Gateway tier sit above the protocol as an independent control plane. This release puts metadata into the transport itself, so the systems infrastructure teams already run can read it. Agent observability stops being a parallel universe and becomes a column in the existing dashboard.
Elicitation got split open too. Server-initiated requests used to require an open stream; now they use multi-round-trip requests. The server returns input_required, the client collects the answer, and retries the call. An approval that was one held connection is now two requests — simpler to deploy, though the human-in-the-loop wait no longer lives inside a single call.
Authorization tightened as well: dynamic client registration is deprecated (removal planned after summer 2027), issuer identification moves to RFC 9207, and clients send a scoped resource URI so tokens are only accepted by the intended audience. Open-source security work is following a similar hardening wave — GLM-5.3 showed what open models can do on safety benchmarks — and MCP is now applying that same discipline to identity.
Is this just REST with extra steps?
The Hacker News debate split sharply — not on whether statelessness is an improvement, but on what it reveals. One camp says this confirms the protocol should never have been stateful. As drdexebtjl put it: "In hindsight, stateful MCP was clearly a mistake. This effectively turns MCP into another REST API endpoint, letting you use the same infrastructure you already built for REST — load balancers, API gateways, progressive rollout." Another commenter was blunter: "We invented a stateful protocol, found state hard to scale, stripped the state, and ended up with 'just send a POST request.' The REST crowd has been waiting 20 years for this moment."
The defenders don't deny the resemblance; they disagree with the conclusion. MCP is JSON-RPC underneath — what was actually invented is a convention models have been trained to use. As vidarh summarized: "The core advantage MCP brings is that it is a standard endorsed by AI providers, so there is strong incentive to actually implement it."
The framework that fits: MCP is not REST with extra steps. It is a routing layer for model-native tool calls — and routing layers always end up stateless, cacheable, and gateway-friendly. The protocol grew up; it just grew up in the direction the web already paved.
What this signals for the agent stack
Adoption is not in dispute: Anthropic reports MCP SDK downloads above 400 million per month, tripling this year. But scale cuts both ways. A consultancy audit on r/AI_Agents found a client's MCP server logged 61 tool calls in three months — 58 of them from the client's own engineers. The post's conclusion echoes this release: "Money is flowing to gateways, registries, and identity layers, not the servers themselves."
Statelessness pushes the same way. When any request can hit any instance, value concentrates in the layer in front of the servers: routing, rate limiting, metering, auth. The protocol just made that layer addressable with standard HTTP tooling — a structural change, not a feature tweak. It also fits the broader pattern of agent infrastructure maturing fast, from DeepSeek's blueprint for self-evolving agents to the protocol layer itself. For teams running MCP in production, the migration path is real but bounded: run a stateless route beside legacy session routing, drain active sessions, and remove the old path inside the deprecation window.
What to do now
- If you operate MCP servers: plan the migration to 2026-07-28. The spec keeps old transports working for at least twelve months, but new traffic should move to stateless routes early.
- If you run a gateway or WAF: start routing and metering on Mcp-Method / Mcp-Name. That is the new control surface for agent traffic.
- If you build agents: expect tool catalogs to become cacheable list responses — clients can cache tool lists and keep prompt caches stable across reconnects.
- If you watch the market: watch the governance layer. The value in the agent stack is consolidating exactly where this spec points: gateways, identity, and transport.
Stateless MCP is a maturation story with an edge: the protocol everyone bet on just admitted it needs to behave like every other API — and that admission is precisely what makes it deployable at enterprise scale.
