InfoQ Architecture·September 25, 2026

Achieving Statelessness: Model Context Protocol (MCP) Removes Session Affinity for AWS Deployments

This article discusses an update to the Model Context Protocol (MCP) specification by AWS, which removes protocol-level session requirements. This change simplifies horizontal scaling for MCP server deployments by eliminating the need for sticky sessions and shared session stores, pushing state management responsibilities to the surrounding infrastructure. It highlights architectural implications for designing scalable, resilient systems, particularly in AI agent deployments.

Distributed Systems Performance & Scaling Cloud & Infrastructure

Read original on InfoQ Architecture

The Challenge of Stateful Protocols in Distributed Systems

In distributed systems, managing stateful connections and protocol-level sessions introduces significant complexity for horizontal scaling and fault tolerance. Traditional approaches often rely on session affinity (sticky sessions) to ensure client requests are consistently routed to the same server instance, or require shared session stores to replicate state across instances. Both methods add overhead, increase latency, and introduce single points of failure or complex consistency challenges.

MCP's Shift to a Stateless Protocol

The updated Model Context Protocol (MCP) specification from AWS addresses these challenges by making the protocol itself stateless. Key changes include the removal of the `initialize` and `initialized` handshake and the `Mcp-Session-Id` header. This architectural decision enables requests to be routed independently to any available server instance, simplifying the deployment behind conventional load balancers.

ℹ️

Stateless vs. Stateful Architecture

A stateless system does not store any client session data on the server. Each request from the client to the server must contain all the information necessary to understand the request. Conversely, a stateful system retains information from previous requests, requiring clients to maintain a session with a specific server or for session data to be shared across servers.

Implications for System Design and Scaling

Simplified Horizontal Scaling: Without sticky sessions, adding or removing server instances becomes trivial, improving elasticity and scalability.
Enhanced Resilience: Any server can handle any request, making the system more resilient to individual server failures.
Reduced Infrastructure Overhead: Eliminates the need for specialized infrastructure to maintain protocol sessions, such as sticky session logic in load balancers or dedicated session storage.
Compatibility with Serverless: The request-response model without persistent session connections makes stateless MCP deployments ideal for serverless platforms like AWS Lambda.

While the protocol itself becomes stateless, application state management remains crucial. The change effectively shifts the responsibility for managing *application-level state* to surrounding infrastructure or client-side logic. This often involves leveraging external data stores, caching mechanisms, or designing idempotent operations for multi-step interactions.

New Features and Architectural Considerations

Gateway Routing and Throttling: New `Mcp-Method` and `Mcp-Name` headers facilitate routing and rate limiting at the API gateway level.
Distributed Tracing: W3C Trace Context support is introduced, essential for observability in distributed systems.
Caching Controls: `ttlMs` and `cacheScope` provide mechanisms for controlling caching behavior.
Idempotency: With stream resumability removed, clients must retry interrupted operations, emphasizing the need for idempotent tool calls to prevent unintended side effects.