MCP 2026-07-28 Spec Ships July 28: Six Breaking Changes to Fix Now

The Model Context Protocol is dropping sessions. On July 28 — nine days from now — the 2026-07-28 specification becomes final, and it removes the initialize handshake, kills Mcp-Session-Id, and makes the protocol fully stateless. If you run an MCP server in production, you have breaking changes to ship. The beta SDKs are already live.

What Stateless Actually Means

Under the current spec, connecting to an MCP server means creating a session. That session lives in Redis, or something like it. Your load balancer has to maintain sticky routing. Your gateway has to inspect request bodies to know where to send traffic. It is the kind of architecture that fights you in production — and developers on Hacker News have been saying so for months.

The 2026-07-28 spec answers those criticisms almost line for line. The new design is simple: every request carries a _meta payload with the client’s capabilities, protocol version, and identity. Any server instance can handle any request. Round-robin load balancers work natively. Session stores disappear. David Soria Parra, who leads the MCP team, put it plainly: “no handshake, no session id, any request can hit any server instance.”

This is the right call. The stateful design was always a friction point, and the protocol is finally catching up with how teams actually run infrastructure.

Six Breaking Changes to Ship Before July 28

Backward compatibility holds until the spec finalizes. After that, you are on the clock. Here are the six things that break:

1. Sessions eliminated. Remove session-based state from your server. If you need cross-call context, mint explicit handles and pass them as ordinary tool arguments.
2. Initialize handshake gone. Implement the new mandatory server/discover RPC. Read protocol version and capabilities from _meta keys on every inbound request instead of from the handshake.
3. Two new required HTTP headers. All Streamable HTTP POST requests must include Mcp-Method (the JSON-RPC method name) and Mcp-Name (the operation name). Servers must reject requests where the headers and body disagree.
4. Tasks API redesigned. Tasks moves from the core spec to an official extension (io.modelcontextprotocol/tasks). The blocking tasks/result call is replaced by polling via tasks/get. If you use Tasks, this is a migration, not a minor update.
5. Error code changed. The missing resource error shifts from -32002 to -32602. Audit your error handling for hardcoded numeric codes and update them to SDK constants.
6. W3C Trace Context now mandatory. Distributed trace propagation rules are strictly mandated. If you use OpenTelemetry or similar, verify your implementation aligns with the RC.

What You Actually Gain

Beyond the architecture cleanup, the spec ships several genuinely useful capabilities.

Response caching lands via a new CacheableResult interface. Add ttlMs (freshness hint in milliseconds) and cacheScope ("public" or "private") to your tools/list, prompts/list, and resources/list responses. Clients can cache results without polling — which matters more in a stateless world where every connection starts cold.

MCP Apps let servers ship interactive HTML interfaces rendered in sandboxed iframes. Templates are declared upfront for security review. Actions taken in the UI follow the same JSON-RPC audit path as direct tool calls.

The Extensions framework establishes a formal process for optional capabilities with independent versioning — meaning protocol extensions can ship and stabilize without waiting for a full spec revision cycle. Tasks and MCP Apps both ship as official extensions under this model.

Get the Beta SDKs Now

All four Tier 1 SDKs have beta releases available today. The TypeScript SDK includes a codemod that automates the v1-to-v2 migration:

# Python
pip install "mcp[cli]==2.0.0b1"

# TypeScript
npm install @modelcontextprotocol/server@beta

# TypeScript codemod (automates migration)
npx @modelcontextprotocol/codemod@beta v1-to-v2 .

# Go
go get github.com/modelcontextprotocol/go-sdk@v1.7.0-pre.1

Go and C# SDKs maintain API compatibility — changes are limited to deprecated features. Python users should follow the dedicated migration guide for the v1 to v2 transition. The TypeScript codemod handles most of the mechanical changes automatically; review the output before committing.

Three New Security Concerns

The stateless redesign closes old attack vectors and opens new ones. Security teams should know about three specifically.

Handle hijacking. The portable handles that replace session IDs are visible to AI models and can appear in logs, tickets, and shared transcripts. Unlike opaque session tokens, they have no built-in binding to user identity or TLS context. A malicious tool response can inject attacker-controlled handles. Validate the (handle + auth context) pair on every request and enforce expiration.

Filesystem scope gap. Deprecating the Roots capability removes structural filesystem boundaries from the protocol. Scope enforcement is now entirely the developer’s responsibility. Research has documented agents accessing hundreds of unrelated files — including database credentials and API keys — when explicit scope controls are absent.

MCP Apps HTML rendering. Server-rendered HTML in IDE iframes creates XSS, clickjacking, and sandbox escape risks. UI mimicry attacks — fake authentication prompts that capture developer credentials — are a real concern. Establish review policies for MCP Apps HTML before deploying them.

What Is Deprecated (But Not Gone)

Three primitives move to deprecated status: Roots, Sampling, and Logging. The HTTP+SSE transport joins them. None are removed — the spec guarantees a minimum 12-month window, running to mid-2027.

The practical guidance: do not start new implementations on these. If you depend on them, add migration to your roadmap but do not treat it as urgent. The 2026-07-28 spec introduces a formal deprecation policy for the first time, and the team is committed to the window.

The Migration Checklist

If you maintain an MCP server or client, here is what to do before July 28:

• Audit existing code for session-state dependencies
• Implement server/discover RPC (now mandatory for servers)
• Add Mcp-Method and Mcp-Name headers to all Streamable HTTP POST requests
• Update error handling to use SDK constants, not hardcoded -32002
• Migrate Tasks implementations from blocking to polling pattern
• Add ttlMs and cacheScope to list and read endpoints
• Verify W3C Trace Context propagation
• Install and test against the RC SDK betas

Nine days is tight. Start with session removal — that is the largest change — and work down the list. The full release candidate announcement has the complete specification detail. The 10-week validation window was there precisely to give teams time to prepare. Use what remains of it.