MCP 2026 Goes Stateless: An Enterprise Deployment and Migration Guide

Model Context Protocol (MCP) is becoming part of the infrastructure enterprises use to connect AI agents to external tools. In December 2025, the Linux Foundation announced the Agentic AI Foundation (AAIF), naming MCP, contributed by Anthropic, as one of its founding projects. That established a path toward open governance and collaboration across vendors.

See the Linux Foundation announcement.

According to the MCP maintainers’ July 28, 2026 announcement, Tier 1 SDKs were approaching 500 million combined monthly downloads, and the TypeScript and Python SDKs had each surpassed one billion cumulative downloads. Downloads measure ecosystem activity, not production deployments. Meanwhile, teams running MCP behind cloud gateways and across large fleets began to encounter the operational costs of protocol sessions. The July 28, 2026 specification addresses those costs with a request-and-response model built around statelessness.

1. Why the old session model was harder to scale

In MCP 2025-11-25 and earlier, clients exchanged version and capability information with servers through initialize before starting normal operations. Stateful HTTP deployments could use Mcp-Session-Id to associate subsequent requests with an existing session. That design worked well for local integrations and bidirectional exchanges, including server-initiated requests.

Horizontal scaling requires a plan for session affinity

On a fleet of five instances, however, a request routed to instance three might need session data stored on instance one. Sticky sessions, a shared Redis store, or changes to the service layer can solve this, but each adds work around deployment, recovery, or operations.

Serverless deployment introduces architecture trade-offs

Older MCP deployments could run on serverless platforms such as AWS Lambda or Cloudflare Workers. The difficulty arose when an application depended on session affinity or hidden state between requests. The new core removes that dependency, so any compatible instance can handle the next request. Your application may still need changes to take advantage of it. See AWS’s architecture discussion.

2. Five changes in the July 2026 specification

Self-describing requests replace the initialization handshake

The July specification removes the initialize and initialized handshake and the protocol-level Mcp-Session-Id header. Requests can carry the protocol version and relevant client or capability information. Over HTTP, the MCP-Protocol-Version header identifies the version, and JSON-RPC _meta can carry additional information. Clients can use server/discover to learn server capabilities in advance when needed.

POST /mcp HTTP/1.1
MCP-Protocol-Version: 2026-07-28
Mcp-Method: tools/call
Mcp-Name: search
Content-Type: application/json

See the specification discussion of handshakes and sessions.

Protocol statelessness still allows application state. Order records, long-running reports, and multi-step workflows can retain progress in a database and carry an explicit identifier across requests.

HTTP routing and standardized cache hints

Streamable HTTP POST requests use Mcp-Method to identify the method and Mcp-Name to identify the relevant tool or resource where applicable. Gateways can use those headers for routing or traffic analysis without parsing the entire JSON-RPC body. Authorization still depends on verified identity, tokens, and server-side checks.

List responses such as tools/list, prompts/list, and resources/list now carry cache information including ttlMs and cacheScope. A public cache can be shared across authorization contexts, while a private cache is restricted to the same authorization context. Stable lists may require fewer repeat requests, but gains depend on list size, lifetime, and client behavior. See the specification changelog and the TypeScript SDK migration guide.

Multi Round-Trip Requests replace some server-initiated exchanges

When a tool needs additional input, a server can return resultType: input_required with the input requirements. The client obtains the response and sends it in a new request using inputResponses. For example, a refund tool can request manager approval when a refund exceeds a configured threshold. The client shows the request to the manager, then resubmits with the decision so processing can continue. The business approval rules remain the application’s responsibility. See Multi Round-Trip Requests in the specification.

Optional Tasks and MCP Apps extensions

The Tasks extension, io.modelcontextprotocol/tasks, lets clients check, update, or cancel long-running work through tasks/get, tasks/update, and tasks/cancel. Batch analysis and document processing can therefore run without keeping a single HTTP request open. Background workers and queues can still handle the work.

MCP Apps lets supporting clients display interactive resources such as forms and dashboards. For example, users can refine filters after an agent retrieves data or see results in a chart. MCP Apps was announced on January 26, 2026 as the first official extension. The July release formalizes the extension framework. Rendering depends on each client’s support and security policies. See the Tasks specification and MCP Apps announcement.

Enterprise authorization and security

The revision advances Client ID Metadata Documents (CIMD) and deprecates Dynamic Client Registration (DCR) while retaining backward compatibility. It also strengthens authorization server issuer verification under RFC 9207 and binds credentials to the appropriate issuer. Enterprise Managed Authorization can help organizations evaluate integration with identity providers such as Microsoft Entra or Okta. Teams must still design for least privilege, token management, audit logging, and tenant isolation. An upgrade does not confer compliance certification. See the MCP authorization changes.

3. MCP 2025 vs. MCP 2026 at a glance

ComparisonMCP 2025MCP 2026-07-28
InitializationExchanges capabilities via initialize and initializedNo initialization handshake
Protocol stateSupports sessions, which some deployments rely onStateless protocol core
Version informationNegotiated during initialization, with additional HTTP version mechanismsVersion travels with every request
Session IDSession-based deployments can use Mcp-Session-IdProtocol header removed
HTTP routingOften relies on request payloads or custom logicStandardized Mcp-Method and Mcp-Name
Tool list cachingNo unified cache hints as in the new specificationttlMs and cacheScope
Multi-turn interactionsCan use server-initiated requestsMRTR with input_required
Long-running tasksEarlier Tasks modelFormal Tasks extension
Interactive UIAvailable through separately developed extensionsMCP Apps in the formal extension ecosystem
OAuth authorizationExisting OAuth and DCR supportStronger issuer verification and adoption of CIMD
Legacy capabilitiesRoots, Sampling, and Logging still availableSelected features subject to the formal deprecation policy

Applications already using simple stateless HTTP may see limited performance change. Fleets that depend on session affinity have more opportunity to simplify their deployment.

4. How Cloudflare and AWS support the new model

Cloudflare: stateless requests on Workers

Cloudflare announced support for the July specification on release day. Its Workers can handle independent requests without dedicating a Durable Object to each protocol session, and its compatibility handling can help existing clients migrate.

AWS: support for both versions through AgentCore Gateway

Amazon Bedrock AgentCore Gateway can be configured for supported protocol versions, allowing existing clients and newer stateless clients to coexist. AgentCore Runtime may still manage its own platform sessions. A stateless protocol can coexist with platform and application state.

5. What enterprises should measure

There is no universal savings figure. A simple lookup service may mainly benefit from standard cache hints and routing. A multi-tenant deployment using sticky sessions or shared session storage may reduce coordination overhead after refactoring. Long-running AI tasks still need durable progress, results, and sometimes queues and workers.

Assess session and storage overhead, load-balancing complexity, cross-instance reliability, SDK and client compatibility, monitoring and audit costs, and the time required for migration, testing, and training. Request latency is only one part of the return on investment.

6. A five-step migration checklist

Step 1: Inventory the protocol versions in use

Identify whether clients and servers use 2025-11-25 or earlier, or support 2026-07-28. Check for the initialization handshake, session IDs, persistent server-initiated requests, and reliance on Roots, Sampling, or Logging.

Step 2: Identify which application state you still need

Distinguish transport state from user authentication and authorization, business records, and long-running task progress. The transport state is the main target of this protocol revision.

Step 3: Choose compatible SDKs and transports

Check migration docs for your language. If some clients still use the previous specification, plan staged migration through a dual-version server or gateway before dropping older support.

Step 4: Review tool caching and authorization isolation

Check that TTLs and cache scopes cannot expose authorization data to other users. Avoid shared caching for tenant-specific tools or sensitive resources merely because lists look alike.

Step 5: Establish regression tests

  • Version selection for new and old clients.
  • Tool calls across different instances.
  • Multi-step input through MRTR.
  • Recovery and status checks after interruptions.
  • OAuth credentials bound to the right identity.
  • Cache isolation between tenants and authorization contexts.

7. Will older MCP deployments stop working immediately?

No. Under the formal policy, a feature becomes eligible for removal at least 12 months after deprecation. Roots, Sampling, Logging, and legacy HTTP+SSE are included in the deprecation plans. The minimum window is not a fixed shutdown date. Check protocol, SDK, and provider support policies and migrate in stages where appropriate. See the release and deprecation policy and Python SDK deprecation notes.

Conclusion

The 2026-07-28 release brings MCP closer to familiar HTTP infrastructure: requests can run independently, gateways can route them, clients can use cache hints, and optional extensions can support more complex workflows. Teams building new enterprise MCP servers can evaluate this revision first. Existing deployments should weigh compatibility and the actual operational benefits. Security, reliability, and cost still depend on authorization design, data isolation, durable tasks, and the workflows being deployed.

Official sources and further reading


已發佈

分類:

作者:

FIRST LINE 新聞室