MCP 2026-07-28: The Big Stateless Update for Agents

The Model Context Protocol, the standard that lets AI agents talk to tools and data, shipped its biggest update ever on July 28, 2026. The new spec makes the protocol core fully stateless, adds an extensions framework for long-running tasks and interactive apps, and moves to OAuth 2.1. For anyone building agents, it changes both the architecture and the economics of agent infrastructure.

What the stateless core changes

The Model Context Protocol shipped its biggest update ever on July 28, 2026. The new spec makes the core fully stateless, adds Tasks and Apps extensions, and adopts OAuth 2.1. Until now, MCP sessions required a handshake and server-side session state. The 2026-07-28 spec removes that: every request is self-describing, there are no handshakes, and no sessions to track. The practical result is that MCP servers can now be deployed serverlessly behind plain round-robin load balancers, with no sticky sessions and no shared session store. GitHub dropped its Redis session store when it adopted the new model, which is a concrete example of the infrastructure simplification. Amazon Bedrock supports the new spec on day one.

Tasks and Apps extensions

The extensions framework formalizes two capabilities that agents have needed for a while. Tasks covers long-running asynchronous work, so a server can accept a job, run it for minutes or hours, and report back through the standard protocol instead of a custom mechanism. MCP Apps lets servers render interactive user interfaces inside sandboxed iframes within the conversation itself, which moves tool output from raw data to actual UI. Both are defined as extensions, so servers that do not need them stay compatible with the minimal core.

How we got here

MCP launched in late 2024 as Anthropic's answer to the fragmentation problem: every AI tool had its own protocol, and every integration required bespoke connector code maintained separately. The protocol defined a simple client-server model where tools expose their capabilities through a standard interface, and any compliant agent can discover and call them. The idea spread because it solved two problems at once: tool builders write one integration, and agent builders implement one protocol. By March 2026, monthly SDK downloads hit 97 million. By late July, after the Claude 5-series models reached broad availability, the number crossed 500 million. That fivefold growth in four months is what forced the stateless redesign: the original session-based architecture was designed for hosted single-tenant servers, not the serverless multi-tenant deployment patterns that the scale demanded.

What the numbers say

The adoption curve tells the story. Monthly MCP SDK downloads hit half a billion, up from 97 million in March, and the ecosystem now has dedicated benchmarks like MCP Atlas that frontier labs cite when positioning agentic models. The protocol went from developer novelty to infrastructure in roughly a year, and the stateless redesign is aimed squarely at the scaling problems that adoption created.

Monthly SDK downloads recently hit 500 million, up from 97 million in March. Amazon Bedrock supports the new spec on day one, and Atlas benchmarks now track agent performance against MCP workloads.

Where MCP fits in the agent stack

MCP is not the only agent communication standard, but it is the one with the most deployment momentum. The stateless redesign removes the infrastructure burden that kept smaller teams on bespoke tool protocols, and the Tasks extension makes it practical for production workloads that run longer than a single request-response cycle. For developers evaluating adoption timing, the question is whether current agent infrastructure has scaling problems the stateless core would solve. If tools depend on sticky sessions, a Redis store, or hand-rolled task queues, the upgrade path is clear. The window where a custom protocol gave an edge over the standard is closing.

Monthly MCP SDK downloads recently hit half a billion, up from 97 million in March, and major platforms including Amazon Bedrock now support the new spec on day one. If you maintain MCP servers, the upgrade path is worth planning now.

The competitive benchmark impact

The MCP Atlas benchmark, now cited by frontier labs including Meta when announcing Muse Spark 1.1's number-one result, has become a de facto standard for measuring agentic model performance against real-world tool protocols. That is significant not just for the protocol itself but for how models are evaluated: a year ago, agentic benchmarks were synthetic and narrow; now they measure performance against the same MCP servers that production deployments actually use. For tool builders, the implication is that the protocol you choose for your integration layer directly affects which models perform best on your specific use case. MCP's dominance means model developers are optimizing for it, and using a different protocol puts you outside the optimization loop that frontier labs are tuning for.

What teams should do

If you maintain MCP servers, the upgrade path is worth planning now: test your servers against the new spec, remove session dependencies, and look at the Tasks extension for anything that currently polls or runs custom job queues. If you build on MCP clients, the stateless core removes a whole class of connection failures, and the Apps extension changes what tool output can look like. The window where a bespoke agent protocol gave you an edge over MCP is closing fast, and this release is the reason. For teams maintaining MCP servers in production, the upgrade path is worth planning now: test against the new spec in a staging environment, remove session dependencies, and evaluate the Tasks extension for workloads that currently rely on custom job queues or polling loops.