MCP Protocol

The Task Protocol allows for long-running operations (e.g., batch migrations, model training) by introducing a non-blocking task ID and polling mechanism, moving beyond the limitations of synchronous client-server calls.

The new 1.720 specification significantly reduces complexity by consolidating capability checks (from three layers to one) and eliminating the insecure `task/list` method, which previously risked exposing all running tasks on the server.

The new protocol replaces the blocking `tasks/result` call for user input with a non-blocking flow. If the server requires input, it changes the status to 'input required,' and the client uses the dedicated `tasks/update` method to send the response.

The updated approach is more amenable to stateless architectures, which aligns with modern best practices for scalable service design. The result of a completed task now comes directly in the `tasks/get` response.

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.

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.

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).

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

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.

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.

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.

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.