The Video Signal

Topic

Stateless Architecture

All digests tagged Stateless Architecture

Stateless, Yet Durable: MCP Tasks v2 thumbnail

· 26:23

Stateless, Yet Durable: MCP Tasks v2

The session details MCP Tasks v2, an architectural evolution designed to enable durable, long-running workflows while maintaining a fundamentally stateless protocol design. Using Purchase Order processing as a concrete example, the talk contrasts the complexity and scalability issues of V1 (which relied on stateful server tracking and polling) with the simplified V2 approach. The key shift involves moving client responsibility for task ID persistence to durable storage and introducing a future notification mechanism to replace inefficient constant polling.

Key takeaways

  1. MCP Tasks v2 Simplification 17:53

    V2 eliminated the complex `task list` functionality (due to scalability concerns) and significantly changed how elicitation flows, simplifying the client-server protocol into basic polling and an explicit `update` API.

  2. Durability vs. Statelessness 4:28

    While the MCP protocol is stateless, the tasks themselves are designed as durable state machines (e.g., invoice processing), requiring robust mechanisms to track their lifecycle states (Working, Input Required, Terminal).

  3. Scaling Beyond Polling 23:50

    For massive scale (millions of tasks), constant polling is inefficient. The future direction involves implementing a notifications mechanism within the MCP Tasks protocol to allow idle tasks to consume zero resources until an event occurs.

Watch on YouTube Full article

MCP Release Overview: Stateless and the Big Changes in the New Spec thumbnail

· 17:48

MCP Release Overview: Stateless and the Big Changes in the New Spec

The latest MCP specification introduces a major architectural shift toward statelessness, fundamentally changing how clients and servers interact. This transition addresses scalability issues inherent in previous stateful designs by ensuring every client request contains all necessary information for the server instance to process it independently. Key updates include Multi Roundtrip Requests (MRTR) for complex flows, formalizing extensions (like MCP Apps and Tasks), and enhancing authorization adherence.

Key takeaways

  1. Transition to Stateless Architecture 3:50

    MCP is moving from a stateful model that relied on session IDs and retained server-side state (requiring an `initialize` call) to a fully stateless design. This eliminates the need for complex shared session stores or sticky load balancing, enabling easier horizontal scaling across multiple server instances.

  2. Multi Roundtrip Requests (MRTR) 7:30

    MRTR simplifies complex tool calls by breaking them into multiple, discrete requests rather than relying on open streams and waiting for responses. This significantly reduces architectural overhead when deploying services behind load balancers.

  3. Formalized Extensions 9:40

    The protocol now supports formal extensions, allowing developers to add specialized functionality without modifying the core spec. Key examples include MCP Apps (for delivering rendered UI) and Tasks (for modeling long-running processes like database migrations or human-in-the-loop workflows).

  4. Authorization Improvements 12:40

    The specification enhances adherence to OAuth standards, requiring authorization servers to return the `iss` parameter. Clients must validate this before redeeming a code.

Watch on YouTube Full article

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

· 22:41

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

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

  1. MCP Protocol Goes Stateless 2:25

    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.

  2. Scaling Challenges in Stateful Systems 5:40

    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.

  3. Infrastructure Overhead of State Management 7:30

    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.

  4. Stateless Scaling Benefits 10:50

    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.

Watch on YouTube Full article

Events Notifications in MCP | ​Aman Singh | MCP Release Party - Seattle thumbnail

· 19:30

Events Notifications in MCP | ​Aman Singh | MCP Release Party - Seattle

The talk introduces a proposed protocol extension for MCP (Messaging/Communication Protocol) designed to enable structured event streams. Currently, MCP only provides lightweight notifications that something has changed without specifying *what* changed or providing a payload. The new Events feature allows agents to subscribe to real-world events (e.g., incidents, emails), supporting three delivery modes—polling, push, and webhooks—to ensure reliable, low-latency communication while maintaining stateless server architecture.

Key takeaways

  1. Structured Event Streams 2:03

    Events allow MCP servers to declare event types with a name, input schema for subscription parameters, payload schema, and supported delivery modes. This moves beyond simple URI notifications to structured data payloads.

  2. Three Delivery Modes 4:00

    The proposed system supports three non-mandatory delivery methods: Simple Polling (self-contained requests using a cursor), Push (for low-latency, long-held connections), and Webhooks (server posts events to a client-provided URL).

  3. Stateless Architecture 6:25

    The new design maintains MCP server statelessness. Polling is inherently stateless, allowing servers to sit behind load balancers and scale horizontally. The SDKs are expected to abstract the complexity of managing these modes for developers.

Watch on YouTube Full article