Engineers building large-scale AI agent architectures have long struggled with the scaling wall. In traditional session-based setups, once a client establishes a connection with a specific server instance, they are effectively tethered to it. This requirement for sticky sessions creates a fragile infrastructure where a single server failure can terminate an entire agentic workflow, and load balancing becomes a complex exercise in session persistence rather than efficient traffic distribution. The industry has been waiting for a way to treat AI tool calls like standard RESTful API requests—autonomous, interchangeable, and infinitely scalable.

The Architecture of the MCP 2026-07-28 Specification

The release of the MCP (Model Context Protocol) 2026-07-28 specification marks the most significant pivot in the protocol's history. The core objective of this update is the complete transition to a stateless protocol, allowing MCP servers to operate seamlessly across standard HTTP infrastructure. To ensure this transition does not break existing enterprise deployments, the maintenance team introduced a new governance framework. This includes a formal feature lifecycle policy, an extensions framework, and a rigorous conformance-suite to ensure that the protocol can evolve without compromising core stability.

Security has also been modernized to align with enterprise standards. The authorization layer is now tightly integrated with OAuth 2.0 and OpenID Connect, moving away from proprietary session keys toward industry-standard identity providers. This update is deployed as an opt-in mechanism. The protocol maintains a dual-track system where existing behaviors persist until both the client and server explicitly adopt the new version, ensuring that the migration happens at the pace of the developer.

Technically, the most drastic change is the elimination of the mandatory handshake. In previous versions, Streamable HTTP interactions required an `initialize` and `initialized` sequence. The server would issue an `Mcp-Session-Id`, which the client had to provide in every subsequent request to ensure it hit the same server instance. The 2026-07-28 spec, via SEP-2575 and SEP-2567, deletes this requirement. Instead, all necessary context—including protocol version, client identity, and capabilities—is packed into a `_meta` parameter within the request itself. To discover server capabilities, clients now use the `server/discover` method, which can be called at any time without needing a prior session.

From Sticky Sessions to Autonomous Request Routing

The shift to statelessness changes the fundamental nature of how AI agents interact with tools. By moving the context from the server's memory to the request's payload, MCP transforms a tool call into a self-contained unit of work. This removes the need for sticky sessions or shared session stores, meaning any server instance in a global cluster can handle any request from any client at any time.

To optimize this for standard HTTP infrastructure, the protocol introduces three critical enhancements. First, the introduction of `Mcp-Method` and `Mcp-Name` headers (SEP-2243) allows API gateways and load balancers to route, throttle, and meter traffic at the HTTP layer. Because the intent is exposed in the header, the infrastructure no longer needs to parse the JSON-RPC body to make routing decisions. If a server detects a mismatch between these headers and the actual body content, it rejects the request immediately to prevent routing errors.

Second, the protocol now supports sophisticated caching through `ttlMs` and `cacheScope` metadata in `list` and `resource-read` responses (SEP-2549). By adopting the semantics of HTTP Cache-Control, clients can cache `tools/list` responses locally. This eliminates the need to maintain expensive, long-lived SSE connections just to keep track of available tools.

Third, the `_meta` parameter now reserves keys for W3C Trace Context, specifically `traceparent`, `tracestate`, and `baggage` (SEP-414). This allows developers to use OpenTelemetry-compatible collectors to visualize the entire call chain—from the agent to the MCP client, through the gateway, and down to the final service—as a single, unified span tree. This level of observability was nearly impossible in the previous session-pinned model.

One of the most complex challenges of a stateless system is handling multi-turn interactions, such as when a server needs more information from a user. The 2026-07-28 spec solves this through Multi Round-Trip Requests (SEP-2322). Instead of holding a connection open, the server returns an `InputRequiredResult` along with an opaque `requestState` token. This token contains the encrypted state of the operation. The server forgets the request entirely, freeing up its memory. When the client returns with the user's input and the `requestState` token, the server uses the token to reconstruct the context and resume the task. This ensures that even if the original server instance crashes, a different instance can pick up the work using the token provided by the client.

For those utilizing Amazon Bedrock AgentCore, the transition is managed via the `UpdateGateway` command. Operators can specify the versions they wish to support to activate the new protocol features:

UpdateGateway --supported-versions "2025-11-25,2026-07-28"

The AgentCore Gateway uses the `Mcp-Protocol-Version` header to determine how to process a request. If a requested version is not in the `supportedVersions` list, the gateway returns an HTTP 400 error with code `-32022` and a list of supported versions. Requests missing the header default to the 2025-03-26 version. Furthermore, the 2026-07-28 path introduces header-binding for tool input schemas. If a required header is missing or conflicts with the body, the gateway triggers an HTTP 400 error with code `-32020`.

By monitoring these specific error codes and utilizing the `UpdateGateway` configuration, engineers can systematically verify that their infrastructure has successfully migrated away from session-dependency toward a truly horizontally scalable architecture.