MCP 2026-07-28 Spec Goes Stateless as Agent Standards Converge

A protocol rebuilt from the ground up

On July 28, 2026, the maintainers of the Model Context Protocol (MCP) published the 2026-07-28 revision of the specification, along with updated SDKs that developers can use right away.21 The main change is a big one. MCP used to be a bidirectional, stateful protocol, and it is now a stateless request/response protocol. The maintainers say this was one of the features developers asked for most, because it makes servers more reliable and easier to scale.21

The reporting agrees that this is a major release. Microsoft's .NET team calls it the largest revision since MCP launched.25 Wikipedia quotes lead maintainer David Soria Parra as calling it the most substantial change since authorization was added to the protocol.17 Google's developer blog calls it a watershed: in Google's view, MCP is moving from a promising local integration layer to core open infrastructure for enterprise AI. Vendor blogs tend to talk up launches, but in this case the technical details back up the claims.

The release followed a set schedule. A release candidate was locked on May 21, 2026. SDK maintainers and client implementers then spent about ten weeks testing it against real workloads before the final version was published.23 The new version replaces 2025-11-25 as the current specification.23

What actually changed

The biggest change is the removal of the initialize/initialized handshake and the Mcp-Session-Id header. Each request now carries its own protocol version, client identity and client capabilities in a _meta field.21 Clients that want to learn a server's capabilities first can call a new server/discover method, but they don't have to. Any request can be handled by any server instance behind an ordinary round-robin load balancer, with no shared storage.12 One migration guide notes that servers needing state across calls now issue explicit handles and pass them as normal tool arguments. That removes the sticky routing and shared session stores that horizontal deployments used to need.23

Several smaller changes support the stateless core:

• Header-based routing. Streamable HTTP requests must now include Mcp-Method and Mcp-Name headers, so gateways, rate limiters and web application firewalls can route and meter traffic without parsing JSON bodies.12
• Cacheable lists. List and read responses now include ttlMs and cacheScope hints, which cut down on repeated fetching.12
• Multi Round-Trip Requests (MRTR). Server-initiated requests such as sampling and elicitation are being redesigned so they no longer need bidirectional streams that stay open.21
• Extensions as a first-class concept. Tasks have left the experimental core and now sit in an extension alongside MCP Apps and Enterprise-Managed Authorization.21

Authorization got stricter as well. Client credentials are now tied to the issuer that created them. Dynamic Client Registration is formally deprecated in favor of Client ID Metadata Documents, though it still works for backward compatibility for now.12 Clients must also check a returned iss value against the issuer they recorded before redeeming an authorization code.23

The changes also include cleanup. Roots, Sampling and Logging are deprecated. Under a new lifecycle policy (SEP-2596), deprecated features must stay in the specification for at least twelve months before they can be removed.23 The Agentic AI Foundation's migration timeline gives July 28, 2027 as the earliest date any deprecated feature could be removed.24 Wikipedia describes the deprecated features as ones that saw limited use.17

Where the coverage diverges

The reports mostly agree on substance but differ on some details. The clearest example is Google's August 5 post, which calls the release a "release candidate" and says the Tier-1 SDKs have beta releases. The maintainers' own announcement says all four Tier-1 SDKs (TypeScript, Python, Go and C#) support the final spec as of launch day, with Rust in beta.21 Several Agentic AI Foundation explainers that were dated in late September still say the specification is "expected to ship."24 These look like older articles that were reposted rather than real disagreements. The specification is final.

The coverage also differs in tone on security. Akamai's analysis agrees that the redesign removes long-standing risks such as session hijacking at the protocol level and unsolicited server prompts. Akamai also argues that, with state and features like rich UI apps and async tasks pushed out of the protocol, developers are now fully responsible for building critical security boundaries. Google makes a similar point more positively: as state management moves to the application layer, security becomes paramount.20 This is the most important caveat in the coverage. A stateless protocol is easier to operate, but it does not secure itself.

Why it matters for enterprise agents

The practical effect is that MCP now works like ordinary web infrastructure. Cloudflare says MCP servers can run on a single Worker with no stateful infrastructure, which lowers both cost and operational complexity.11 Microsoft's C# SDK v2.0 points out that proxies, WAFs and observability tools can now handle MCP traffic without deep packet inspection.25 Gravitee, an API gateway vendor, describes servers that can sit behind standard load balancers without Redis or session-stickiness logic.14

Early adopters report measurable results. Manufact, which hosts thousands of MCP servers, says the new SDK reduced its package size by about 83% and made it about 25% faster.12 A Cloudflare customer said they went live before the specification was final and production didn't break.22

Enterprise-Managed Authorization may matter more to large organizations than any of the transport changes. It lets IT administrators grant access to MCP servers centrally through an identity provider, so users are connected automatically when they log in instead of clicking through OAuth prompts for each app.24 Many security teams want this kind of central control before they approve autonomous agents that touch business data.

The overall direction is clear: this release puts operability and governance ahead of new features. A formal deprecation policy, an extensions framework that keeps the core small, and authorization that follows OAuth and OIDC norms are the kinds of guarantees procurement and platform teams look for. One explainer notes that the maintainers' roadmap lists transport and scalability, agent communication, governance and enterprise readiness as its focus areas.13

The A2A convergence

The release came out as the agent-standards landscape was consolidating. In August 2026, Google's Agent2Agent (A2A) protocol joined the Agentic AI Foundation, a Linux Foundation body. A2A now sits under the same governance as MCP.110 The reported date of the move varies. Cryptothreads, citing Axios, says August 17.10 Enterprise DNA says August 20.1

The two protocols handle different layers. MCP connects an agent to its tools and data, while A2A connects independent agents to each other. Most production stacks run both.4 A2A has also matured. The Linux Foundation said A2A had more than 150 supporting organizations at its one-year mark in April 2026, with production deployments in supply chain, financial services, insurance and IT operations.3 Its version 1.0 added signed Agent Cards for cryptographic identity, along with multi-tenancy.3 The v1.0 release date differs between sources: some say March 2026106 and others April 2026.58

The foundation's size is also reported inconsistently. Cryptothreads, citing Axios, says the Agentic AI Foundation grew from fewer than 40 members at its December 2025 launch to more than 250 by August 2026.10 Enterprise DNA describes a March 2026 start with 49 founding members and lists AWS, Anthropic, Google, Microsoft and OpenAI among its top-tier backers.1 Both sources agree that membership grew quickly.

The two protocols are also starting to look alike. A2A v1.0 advertises an architecture built around familiar web security and load-balancing patterns.3 MCP's new release moves toward the same stateless, HTTP-native model. Both are being built to run on existing enterprise web infrastructure.

The open questions

Neither protocol is finished. A2A defines the message envelope but not the contents of skill payloads, so two agents that both offer a "search inventory" skill may expect completely different inputs.4 One technical guide notes that A2A still has no standard registry API for discovering agents, which leaves enterprises to build their own.9 On the MCP side, teams that relied on sessions or the experimental Tasks feature have real migration work. Those changes are listed as breaking.23

The main takeaway is that agent interoperability now looks more like ordinary infrastructure planning and less like a bet on one vendor. The underlying standards are under neutral governance, follow published deprecation timelines and are designed to run on standard HTTP infrastructure. Each enterprise still has to decide where security boundaries go once the protocol no longer holds state. As Akamai warns, that responsibility now sits with the people building on the standard.