# MCP Goes Stateless | ​John Dellenbaugh & Pankaj Kumar | MCP Release Party - Seattle

## Executive summary

This session details the transition of the MCP protocol to a stateless architecture, significantly simplifying horizontal scaling for AI agent workflows. Previously, maintaining state required complex infrastructure like sticky gateways and dedicated session stores. The new stateless specification eliminates this dependency, allowing agents to interact with services across multiple instances using standard load balancing techniques while preserving conversational context.

## Key takeaways

- MCP Protocol Goes Stateless: The updated MCP specification (2026-07-28) makes the protocol stateless, eliminating session management at the protocol level. This removes a major architectural bottleneck for scaling.
- Scaling Challenges in Stateful Systems: In stateful setups, scaling out instances leads to 'session not found' errors because subsequent requests may land on an instance that does not hold the session data created by a previous instance.
- Infrastructure Overhead of State Management: To maintain state in legacy systems, developers must implement complex infrastructure like sticky gateways (mapping Session ID to Instance ID) and dedicated session stores, adding significant overhead.
- Stateless Scaling Benefits: The stateless model allows for standard load balancing across multiple instances without requiring external state management infrastructure. The cart ID effectively replaces the need for a dedicated session store.

## Technical details

- Stateful Scaling Demo (Legacy): The demo showed that when an agent interacts with multiple MCP server instances, the initial 'create card' call establishes a session on Instance A. If subsequent calls land on Instance B, they fail because Instance B lacks knowledge of the active session ID.
- Stateful Mitigation Techniques: The primary solutions for stateful scaling involve implementing a sticky gateway (to route requests based on Session ID) and a centralized session store (to persist conversation data across restarts/failures).
- Stateless Architecture Implementation: The modern, stateless setup uses standard load balancers. The cart ID is now the primary identifier that persists in the database, removing the dependency on the MCP system itself to manage session state.
- Security Considerations: The speakers explicitly stated that going stateless does not inherently solve security issues; proper security handling must still be implemented by the developer.

## Practical implications

- Architects can simplify system design by removing the need for dedicated session management layers (sticky gateways and session stores) when building AI agent tools.
- The stateless nature of MCP facilitates true horizontal scaling, making it easier to handle massive increases in concurrent user load.
- Developers must still apply standard engineering best practices regarding durability and resiliency, as the protocol itself does not solve these issues.

## Topics

MCP Protocol, Stateless Architecture, Horizontal Scaling, AI Agent Workflows, System Design, Load Balancing, GitHub Repo (JohnDell914)

Source: https://www.youtube.com/watch?v=banffxk7EqQ