MCP Goes Stateless: What the July 2026 Spec Rewrite Means for Your Architecture

The Biggest MCP Revision Since Launch

On July 28, 2026, the Model Context Protocol specification received its largest revision since Anthropic open-sourced the protocol in late 2024. This was not a point release with incremental improvements. It was a fundamental architectural rewrite that changes how MCP clients and servers interact, how state is managed, how authorization works, and how the protocol fits into the broader agent ecosystem.

The scale of adoption that drove these changes is staggering: MCP is now approaching 500 million monthly downloads across its various SDK implementations. What started as an experimental protocol for connecting AI models to tools has become critical infrastructure for the agent ecosystem. With that adoption comes the hard lessons of production use — and the July revision reflects every one of those lessons.

I have been tracking MCP's evolution since its launch and have written extensively about how it fits into enterprise architecture. This revision is the most significant one to date, and every enterprise architect building agent systems needs to understand what changed, why it changed, and what it means for existing and planned deployments. Let me walk through the major changes and their architectural implications.

Core Goes Stateless: The Initialize Handshake Is Gone

The most fundamental change in the July revision is the shift to a stateless core protocol. In previous versions of MCP, every client-server interaction began with an initialize handshake — a request-response exchange where the client and server negotiated protocol version and capabilities before any actual work could begin. This handshake established a stateful session between client and server.

The July revision eliminates this handshake entirely. Instead, the protocol version and client capabilities now travel per-request in a _meta field on every JSON-RPC message, alongside a new MCP-Protocol-Version HTTP header on Streamable HTTP transports. There is no up-front negotiation. Every request is self-contained with all the context the server needs to process it.

For servers that still want or need up-front capability negotiation, the revision introduces a new optional server/discover RPC method. Clients can call server/discover to learn about the server's capabilities before making tool calls — but this is optional, not required. A well-formed MCP request can be processed by a server with no prior interaction.

Why does this matter architecturally? The shift to stateless changes everything about how MCP can be deployed:

• Load balancing becomes trivial: with stateless requests, any server instance can handle any request. There is no session affinity requirement. Standard HTTP load balancers work without sticky sessions. This is a massive operational simplification for high-availability MCP deployments.
• Scaling is horizontal: stateless MCP servers can be scaled out by simply adding instances behind a load balancer. There is no shared session state to synchronize across instances. Kubernetes horizontal pod autoscaling works naturally.
• Resilience improves: if an MCP server instance crashes, the next request can be routed to any other instance with no state loss. There are no orphaned sessions to clean up, no reconnection logic to implement, no session recovery mechanisms to build.
• Caching becomes possible: stateless requests with deterministic semantics can be cached at the infrastructure level. An MCP gateway can cache tools/list responses, resources/read results, and even some tools/call responses when the tool is idempotent. The new ttlMs and cacheScope cache hint fields in the July revision explicitly support this pattern.
• Serverless deployment works: stateless MCP servers are natural candidates for serverless platforms (AWS Lambda, Google Cloud Functions, Cloudflare Workers). Each request is independent, startup time is the only concern, and the infrastructure manages scaling automatically. This was impractical with stateful sessions that required persistent connections.

The move to stateless is the single most impactful change for enterprise MCP infrastructure. It aligns MCP with the same stateless-by-default design philosophy that made HTTP and REST successful at scale. Stateful interactions are still possible when needed — but they are now opt-in rather than the default, using explicit mechanisms rather than implicit session state.

Sessions Removed: Mcp-Session-Id Is Gone

Closely related to the stateless core, the July revision removes the Mcp-Session-Id header from the Streamable HTTP transport. In previous versions, the server issued a session ID during the initialize handshake, and the client included it in subsequent requests to maintain session affinity.

With sessions gone, cross-call state now moves through explicit server-minted handles passed as tool arguments. If a tool call needs to reference state from a previous call — for example, a pagination cursor, a transaction reference, or a multi-step workflow identifier — the server returns a handle in the tool's response, and the client passes that handle back in subsequent calls. State is explicitly managed through the tool interface, not implicitly through the transport layer.

This is a cleaner design for several reasons:

• State is visible: when state travels as tool arguments, it is visible in the tool call — you can see it in logs, inspect it in debugging, and reason about it in the application logic. Implicit session state is invisible at the application layer, making debugging and auditing harder.
• State scope is explicit: a server-minted handle is scoped to the specific interaction that created it. It does not grant access to all the state accumulated in a session. This is a principle of least privilege applied to state management.
• State management is the server's responsibility: the server decides what state to persist, how long to persist it, and what handles to issue. The transport layer does not impose a state management model on the application. Different tools on the same server can manage state differently — some stateless, some with short-lived handles, some with durable handles — all coexisting naturally.

For enterprise architects, the session removal means simplifying your MCP infrastructure. Session affinity configurations, session store infrastructure, and session cleanup logic can all be removed. In their place, you need to ensure that your MCP tools properly issue and validate handles when cross-call state is required — but this is application-level logic, not infrastructure-level complexity.

Server-Initiated Requests Replaced: The input_required Pattern

Previous versions of MCP supported server-initiated requests — the server could proactively reach back to the client to request information. This created a bidirectional communication pattern that was powerful but complex: both client and server could initiate requests, creating interleaved request-response flows that were difficult to debug, proxy, and load-balance.

The July revision replaces server-initiated requests with the input_required pattern, formalized as Multi Round-Trip Requests. Instead of the server initiating a new request to the client, the server returns a response with a status indicating that additional input is needed. The client processes this response, gathers the required input, and makes a new request. Communication remains strictly client-initiated — the server only responds, never initiates.

This is a significant simplification of the protocol's communication model:

• Proxying becomes straightforward: a proxy only needs to handle client-to-server requests and server-to-client responses. There are no server-initiated requests to forward to the client, no reverse channels to maintain, no bidirectional routing complexity.
• Firewall and network traversal is simpler: client-to-server traffic follows standard outbound request patterns. There are no inbound server-initiated connections to configure, no WebSocket-like bidirectional channels required for basic operation.
• Error handling is cleaner: when the server needs input, it returns a well-defined status rather than initiating a request that might time out, fail to deliver, or arrive when the client is not ready. The client controls the flow, retrying or gathering input at its own pace.

The input_required pattern does add one complexity: multi-round-trip tool calls are no longer atomic from the client's perspective. A single logical operation (e.g., "execute this database migration with confirmation") may require multiple request-response cycles. Clients need to handle this multi-step flow, and timeouts need to account for human-in-the-loop delays when the required input comes from a user. But this complexity exists at the application level, where it belongs, rather than at the protocol level, where it complicated everything.

Deprecations: Sampling, Roots, and Logging

The July revision deprecates three protocol features with a 12-month sunset window: Sampling, Roots, and Logging. Each deprecation reflects a lesson learned about protocol scope and responsibility.

Sampling (Deprecated)

Sampling allowed MCP servers to request that the client perform an LLM inference — essentially letting the server use the client's model access to process data. This was always an uncomfortable feature: it inverted the expected flow of control (servers requesting model access from clients), created security concerns (a malicious server could use client-side model access to exfiltrate data through crafted prompts), and conflated two different concerns (tool execution and model inference).

The migration path is to use direct LLM provider APIs from the server side. If an MCP server needs model inference, it should call the model API directly rather than routing through the client. This is cleaner, more secure, and easier to govern — model access policies can be applied to the server's direct API calls rather than to the indirect sampling channel.

Roots (Deprecated)

Roots provided a mechanism for the client to inform the server about filesystem paths that are relevant to the current context. In practice, this was fragile (paths are client-specific and may not be accessible from the server), overly broad (exposing a root directory grants access to everything beneath it), and better handled through explicit tool parameters.

The migration path is to pass file paths or identifiers as tool parameters. Instead of the client declaring a root and the server implicitly using it, the client passes specific paths to specific tools as explicit arguments. This is more precise, more auditable, and works correctly in remote and distributed deployments where the server may not have filesystem access to the client's paths.

Logging (Deprecated)

Logging allowed MCP servers to send log messages to the client through the protocol. This was convenient for development but architecturally misplaced — logging is an operational concern that belongs in the server's infrastructure, not in the client-server protocol.

The migration path is to use stderr for local development (where the client can capture it) and OpenTelemetry for production deployments (where logs should flow to centralized observability infrastructure). This aligns MCP logging with standard observability practices rather than inventing a protocol-specific logging channel.

The 12-month deprecation window gives enterprises time to migrate, but architects should plan their migrations now. Any MCP server that relies on Sampling, Roots, or Logging needs to be updated before the July 2027 sunset. Starting migration early avoids a rush at the deadline and ensures that the replacement patterns (direct LLM APIs, explicit tool parameters, OpenTelemetry) are well-tested before the deprecated features are removed.

Tasks Moved to an Extension

The Tasks capability — which allowed MCP servers to manage long-running operations with progress tracking and cancellation — has been moved out of the core protocol and into an official extension. This is not a deprecation; Tasks is still fully supported. But it is no longer part of the core specification that every MCP implementation must understand.

The rationale is scope management. The core protocol should define the minimal set of capabilities that every MCP client and server needs to support. Tasks, while valuable for long-running operations, is not universally needed — many MCP servers handle synchronous, quick-returning tool calls that do not benefit from task management overhead. Making Tasks an extension means that implementations that need it can opt in, while simpler implementations remain simple.

For enterprise architects, this has a practical implication for MCP server selection and compatibility: if your architecture relies on long-running MCP operations with progress tracking, you need to verify that both your MCP clients and servers support the Tasks extension, not just the core protocol. Extension support is not guaranteed — it must be checked during integration testing and documented in your MCP server catalog.

Authorization Tightened: Security Gets Serious

The July revision significantly tightens MCP's authorization model, reflecting the security requirements of production deployments where MCP servers access sensitive enterprise data.

The key authorization changes:

• RFC 9207 issuer validation: MCP clients must now validate the iss (issuer) claim in authorization server metadata using the RFC 9207 mechanism. This prevents a class of attacks where a malicious server could redirect authorization to a different (compromised) authorization server. Clients verify that the authorization server they are talking to is the one the MCP server actually trusts.
• Credentials bound to authorization server: tokens and credentials are now explicitly bound to the authorization server that issued them. A token issued by Authorization Server A cannot be used with Authorization Server B, even if both protect the same MCP server. This prevents token confusion attacks in environments with multiple authorization servers.
• Dynamic Client Registration deprecated: the OAuth 2.0 Dynamic Client Registration mechanism is deprecated in favor of Client ID Metadata Documents. Dynamic registration allowed any MCP client to register with any MCP server's authorization server automatically — convenient but difficult to govern. Client ID Metadata Documents provide a static, auditable mechanism for client registration that gives enterprises control over which clients can access which servers.

These authorization changes are enterprise-friendly but require infrastructure work. Your MCP clients need to implement RFC 9207 validation. Your authorization servers need to support credential binding. Your client registration process needs to move from dynamic registration to metadata documents. If you are using an off-the-shelf MCP SDK, check whether the latest version supports these requirements — and if not, plan for an SDK update.

Transport Changes: Headers, Caching, and Legacy Deprecation

The July revision makes several changes to MCP's transport layer that affect how MCP traffic flows through infrastructure:

• Mcp-Method and Mcp-Name headers: Streamable HTTP requests now include Mcp-Method and Mcp-Name headers that expose the JSON-RPC method and tool name at the HTTP level. This is a huge win for infrastructure visibility — MCP-aware proxies, gateways, and load balancers can now route and filter based on these headers without parsing the JSON-RPC body. Rate limiting per MCP method, routing specific tools to specific server pools, and logging tool usage at the infrastructure level all become possible with standard HTTP header inspection.
• SSE resumability removed: the Server-Sent Events resumability mechanism (using Last-Event-ID for reconnection) is removed. This was part of the legacy HTTP+SSE transport and is no longer needed with the stateless core. Clients that need to recover from connection drops simply retry the request — since requests are stateless, retries are idempotent (or use handles for stateful operations).
• Cache hints: the new ttlMs and cacheScope fields on tool responses allow servers to hint at caching behavior. ttlMs specifies how long a response can be cached. cacheScope specifies whether the cache is per-user, per-session, or global. Infrastructure-level caching of MCP responses — at gateways, proxies, or CDN layers — becomes possible and governed by server-specified policies.
• Legacy HTTP+SSE deprecated: the original HTTP+SSE transport (which used separate endpoints for sending and receiving) is formally deprecated in favor of Streamable HTTP. This was expected — Streamable HTTP was introduced specifically to replace the more complex dual-endpoint SSE pattern. Enterprises still using the legacy transport should migrate to Streamable HTTP as part of their July revision adoption.

The transport changes, especially the Mcp-Method and Mcp-Name headers, close a critical gap I have written about previously: the inability of infrastructure tools to understand MCP traffic semantics. With these headers, existing HTTP infrastructure gains MCP visibility without requiring custom protocol parsing. This is a pragmatic, infrastructure-friendly design choice that will accelerate enterprise MCP adoption.

A2A Joins AAIF: Protocol Governance Consolidates

On August 17, 2026 — three weeks after the MCP revision — Google's Agent-to-Agent (A2A) protocol joined the Agentic AI Foundation (AAIF) alongside MCP. Both protocols now share a neutral governance home, independent of their originating companies (Anthropic for MCP, Google for A2A).

This is a significant governance milestone. With both major agent protocols under AAIF, there is now a single venue for coordinating protocol evolution, resolving interoperability questions, and aligning on shared infrastructure standards. The risk of protocol fragmentation — MCP and A2A evolving in incompatible directions — is substantially reduced.

AAIF has established eight working groups to drive standards across the agent ecosystem:

• Accuracy & Reliability: standards for measuring and improving agent accuracy, including evaluation frameworks, benchmark methodologies, and reliability metrics.
• Agentic Commerce: standards for agents participating in commercial transactions — payments, contracts, marketplace interactions, and economic exchange between agents.
• Governance, Risk & Regulatory: frameworks for agent compliance with regulatory requirements, risk management, and organizational governance policies.
• Identity & Trust: agent identity, authentication, delegation, and trust establishment — the foundation for secure multi-agent systems.
• Observability & Traceability: standards for agent-level observability, extending existing frameworks like OpenTelemetry with agent-aware semantics.
• Security & Privacy: security primitives for agent systems, including prompt sanitization, data flow policies, and privacy-preserving agent interactions.
• Workflows & Process Integration: standards for agents integrating with existing enterprise workflows, business processes, and automation systems.
• Taxonomy & Landscape: shared vocabulary and conceptual framework for the agent ecosystem, ensuring that the industry uses consistent terminology.

For enterprise architects, AAIF's consolidation of protocol governance and standards work is unambiguously positive. It provides a single venue to track, a single set of standards to plan for, and a single governance model to engage with. If you are not already monitoring AAIF working group outputs, start now — the standards they produce over the next 12-18 months will shape agent infrastructure for years to come.

Practical Migration Guide: What to Do Now

If you have existing MCP infrastructure — whether a few MCP servers in development or a production deployment — here is a prioritized migration plan for the July revision:

Phase 1: Immediate (0-3 months)

• Update MCP SDKs to the latest versions that support the July revision. Most major SDKs (TypeScript, Python, Java, Go) have already released compatible versions. This is the foundation for everything else.
• Add per-request _meta and MCP-Protocol-Version headers to all MCP clients. Even if your servers still accept the old initialize handshake (most will, during the transition), starting to send per-request context prepares for the stateless future.
• Audit Sampling, Roots, and Logging usage across your MCP servers. Identify which servers use deprecated features and estimate the migration effort. You have 12 months, but knowing the scope now prevents surprises.
• Emit Mcp-Method and Mcp-Name headers from all Streamable HTTP MCP clients and verify that your infrastructure can see them. Update logging and monitoring configurations to capture these headers.

Phase 2: Near-term (3-6 months)

• Migrate from session-based to stateless deployment. Remove session affinity configurations from load balancers. Replace session-based state with explicit server-minted handles in tools that need cross-call state. Test that your MCP servers handle any-instance routing correctly.
• Replace Sampling with direct LLM API calls. This is typically the most complex migration — servers that use Sampling need to be refactored to call model APIs directly, which requires them to have their own model credentials and access management.
• Replace Roots with explicit tool parameters. Update MCP clients to pass file paths and identifiers as tool arguments rather than declaring Roots. Update server tools to accept these parameters.
• Implement RFC 9207 issuer validation in all MCP clients. This is a security requirement that should not be delayed.

Phase 3: Medium-term (6-12 months)

• Migrate from Dynamic Client Registration to Client ID Metadata Documents. This requires coordination between client teams and server teams — plan the cutover carefully.
• Replace Logging with OpenTelemetry. Set up OpenTelemetry collectors for your MCP servers. Configure log export from servers to your observability platform. Remove protocol-level logging calls.
• Migrate from legacy HTTP+SSE to Streamable HTTP. If you still have servers or clients using the legacy transport, complete the migration before it is removed in a future revision.
• Implement cache hints on appropriate MCP server responses. Identify tools with cacheable responses, add ttlMs and cacheScope hints, and configure infrastructure-level caching at your MCP gateway or proxy layer.

What This Means for the Enterprise Agent Stack

The July 2026 MCP revision is more than a protocol update. It is a maturation signal. The protocol has moved from "ambitious experiment that tries to do everything" to "focused infrastructure that does the essential things well and delegates the rest to purpose-built layers."

Stateless core means MCP fits naturally into enterprise infrastructure patterns — load balancing, horizontal scaling, caching, serverless deployment. Session removal means simpler infrastructure with explicit state management. Authorization tightening means production-grade security. Transport headers mean infrastructure visibility. Deprecations mean a smaller, cleaner protocol surface that is easier to implement, test, and govern.

Combined with A2A's entry into AAIF and the eight working groups driving cross-cutting standards, the agent protocol ecosystem is maturing rapidly. The direction is clear: agent protocols are becoming enterprise infrastructure, designed for the same scalability, security, and operability requirements that enterprises demand from their existing technology stacks.

The July revision is not the end of MCP's evolution — it is the beginning of MCP as production infrastructure. Architects who plan their migrations now and align their infrastructure with the new stateless, header-enriched, extension-based architecture will be well-positioned for the next phase of enterprise agent adoption. Those who delay will find themselves managing legacy MCP infrastructure that increasingly diverges from the ecosystem's direction.

Start migrating. The protocol has grown up, and your infrastructure should too.