MCP 2026-07-28 Release Candidate: The Protocol's Biggest Overhaul Yet, AI Agent Infrastructure Goes Stateless

The Model Context Protocol has just dropped its 2026-07-28 release candidate, and it's the biggest revision since launch. If you're building or operating MCP servers, this one deserves your full attention.

The headline

MCP has gone from a stateful protocol requiring session affinity to a fully stateless protocol that runs on commodity HTTP infrastructure. Alongside this, a formal Extensions framework lets MCP Apps and Tasks evolve on their own timelines, independent of the core spec.

Stateless: the biggest architectural shift

In the 2025-11-25 spec, calling an MCP tool required establishing a session first:

POST /mcp HTTP/1.1
Content-Type: application/json

{"jsonrpc":"2.0","id":1,"method":"initialize",
 "params":{"protocolVersion":"2025-11-25","capabilities":{},
           "clientInfo":{"name":"my-app","version":"1.0"}}}

The server responded with an Mcp-Session-Id that every subsequent request had to carry — pinning clients to a single instance and forcing sticky routing with shared session stores.

In 2026-07-28, the same call is a single self-contained request:

POST /mcp HTTP/1.1
MCP-Protocol-Version: 2026-07-28
Mcp-Method: tools/call
Mcp-Name: search
Content-Type: application/json

{"jsonrpc":"2.0","id":1,"method":"tools/call",
 "params":{"name":"search","arguments":{"q":"otters"},
           "_meta":{"io.modelcontextprotocol/clientInfo":{"name":"my-app","version":"1.0"}}}}

Any instance can handle it. No sticky routes. No shared session stores.

What changed under the hood

Six SEPs (Specification Enhancement Proposals) work together to make this happen:

• The initialize/initialized handshake is gone (SEP-2575). Protocol version, client info, and capabilities now travel in _meta on every request. A new server/discover method lets clients fetch capabilities upfront when needed.
• Mcp-Session-Id and the protocol-level session are removed (SEP-2567). Requests land on any instance. Horizontal scaling just got dramatically simpler.
• Explicit handles replace implicit sessions. Need state across calls? The server mints a basket_id or browser_id and the model passes it as an ordinary argument. This is arguably more powerful — the model can compose handles across tools and reason about them.
• Server-to-client requests, restructured (SEP-2260 & SEP-2322). Servers may only initiate requests while actively processing a client request. The InputRequiredResult + requestState mechanism replaces long-lived SSE streams for elicitation.
• Routable, cacheable, traceable (SEP-2243, SEP-2549, SEP-414). Mandatory Mcp-Method and Mcp-Name headers enable operation-level routing at the gateway. List results carry ttlMs and cacheScope. W3C Trace Context propagation is now baked into the spec.

Extensions become first-class

Extensions existed in 2025-11-25 but had no formal process. SEP-2133 fixes that:

• Identified by reverse-DNS IDs
• Negotiated through an extensions map on capabilities
• Live in independent ext-* repositories with delegated maintainers
• Version independently of the specification

Two official extensions ship with this release:

MCP Apps: server-rendered UIs

Servers can ship interactive HTML interfaces rendered in sandboxed iframes by the host. Tools declare UI templates ahead of time so hosts can prefetch, cache, and security-review them. Every UI-initiated action goes through the same audit and consent path as a direct tool call.

Tasks extension

Tasks graduates from an experimental core feature to a standalone extension, redesigned around the stateless model. Servers drive long-running work through tasks/get, tasks/update, and tasks/cancel. Implementations built against the 2025-11-25 experimental Tasks API will need to migrate.

Authorization hardening

Six SEPs tighten authorization to align with real-world OAuth 2.0 and OpenID Connect deployments:

• Clients must validate the iss parameter per RFC 9207 (mitigates mix-up attacks)
• application_type declaration during Dynamic Client Registration prevents desktop/CLI clients from being misidentified as web
• Credentials bind to the issuing authorization server's issuer
• Refresh token support from OIDC-style authorization servers
• Clarified scope accumulation and .well-known discovery

Roots, Sampling, and Logging are deprecated

Feature	Replacement
Roots	Tool parameters, resource URIs, or server configuration
Sampling	Direct integration with LLM provider APIs
Logging	stderr for stdio transports; OpenTelemetry for structured observability

These are annotation-only deprecations. All three continue to work in this release and for at least twelve months thereafter. Removal requires a separate SEP.

JSON Schema 2020-12

Tool inputSchema and outputSchema upgrade to full JSON Schema 2020-12 (SEP-2106). Input schemas keep the type: "object" root constraint but now support oneOf/anyOf/allOf, conditionals, and references. Output schemas are unrestricted.

Timeline

• May 21, 2026: Release candidate locked
• July 28, 2026: Final specification ships

The ten-week window is for SDK maintainers and client implementers to validate against real workloads. Tier 1 SDKs are expected to ship support within this window.

Why this matters

For anyone running MCP in production:

• Deployment complexity plummets. No more sticky sessions, shared stores, or deep packet inspection. A plain round-robin load balancer is enough.
• Extensions unlock independent innovation. MCP Apps and Tasks can iterate on their own schedule without blocking on core spec releases.
• Observability is built in. W3C Trace Context propagation means a trace that starts in a host app can follow a tool call through the client SDK, the MCP server, and downstream services — all as a single span tree.
• Migration is protected. The formal deprecation policy guarantees at least twelve months before any feature can be removed.

For the AI agent ecosystem, this may be the most significant infrastructure update of 2026. MCP has transformed from a protocol that demanded careful operations engineering into one that deploys on standard HTTP infrastructure — clearing a critical barrier to production-scale agent deployments.