Технологічна галузь

MCP переходить у безстатусний режим: Що змінилося в протоколі 2026 для розробників AI-агентів

MCP Goes Stateless: What the 2026 Protocol Changes for AI Agent Developers

Протокол контексту моделі перейшов за межі своєї оригінальної сесійної архітектури. Специфікація 2026-07-28 робить MCP безстатусним, полегшуючи масштабування за допомогою стандартної HTTP інфраструктури, і краще підходить для виробничих AI-агентів. Ось що змінилося, чому це важливо і що розробники повинні переглянути в існуючих серверах MCP.

The Model Context Protocol has evolved quickly from a convenient way to connect AI models to tools and data into a serious piece of agent infrastructure.

That evolution created a problem.

The first generations of remote MCP servers were designed around protocol-level sessions. A client initialized a connection, the server issued a session identifier, and subsequent requests remained associated with that session.

That works well when an AI client is talking to a single server process. It becomes less attractive when the same MCP service needs to run across multiple containers, regions or cloud instances.

The 2026-07-28 MCP specification changes that architecture fundamentally: the modern MCP lifecycle is stateless at the protocol level.

For developers building production AI agents, this is more than a protocol detail. It changes how MCP services can be deployed, scaled and integrated with conventional HTTP infrastructure.

Why MCP needed to become stateless

Earlier versions of MCP used an initialization handshake. A client connected to an MCP server, sent an initialize request and negotiated capabilities and a protocol version. With Streamable HTTP, a server could also issue an Mcp-Session-Id that identified the session on later requests.

If several MCP server instances sit behind a load balancer, the infrastructure may therefore need sticky routing or shared session storage. The new architecture removes that requirement from the protocol itself.

What changed in MCP 2026-07-28?

The protocol-level session disappears from the modern lifecycle. The initialize handshake used by the previous protocol era is no longer part of that lifecycle, and the Mcp-Session-Id mechanism has been removed.

Instead, modern clients discover a server and send requests containing enough protocol information to be processed independently. The practical result is important: request A and request B no longer need to reach the same MCP server instance simply because they belong to the same protocol session.

A conventional load balancer can distribute them between available instances.

Stateless MCP does not mean stateless applications

Removing MCP's protocol session does not mean an application can no longer maintain state.

Imagine an MCP tool that creates a shopping basket. Instead of storing a hidden basket inside an MCP session, the tool can return an explicit identifier:

basket_id: basket_84721

A later tool call can accept that identifier:

add_item(
    basket_id: "basket_84721",
    product_id: "product_42"
)

The state still exists. It simply belongs to the application rather than to the transport protocol. This pattern will feel familiar to web developers: REST APIs routinely expose identifiers for carts, jobs, conversations, files or workflows instead of expecting an HTTP connection itself to remember application state.

Why this matters for horizontal scaling

Consider a remote MCP server running on three application instances:

AI client
    |
Load balancer
    |
+---------+---------+
|         |         |
MCP #1   MCP #2   MCP #3

With protocol-level session state, infrastructure may have to keep a particular client attached to one instance or replicate its session data. With the modern stateless lifecycle, each compatible request can be handled independently.

That makes round-robin load balancing, autoscaling, ephemeral containers, rolling deployments, serverless runtimes and multi-instance Kubernetes deployments easier to apply.

Discovery replaces part of the old initialization model

If there is no long-lived initialization exchange, a client still needs to know what the server supports. The new lifecycle introduces server discovery.

Instead of relying on information negotiated once and retained as session state, modern MCP implementations can expose their capabilities through the discovery model. The 2026 specification also introduces TTL information for list results, allowing clients to know how long discovered information can reasonably be reused.

For large deployments, caching unchanged tool lists reduces unnecessary overhead.

Server-to-client interactions had to change too

Going stateless creates a harder challenge for interactions initiated by the server. Suppose a tool is executing and needs additional information from the user.

The 2026 MCP architecture introduces Multi Round-Trip Requests (MRTR) to support interactions that require additional client input without restoring a permanent protocol session.

Server-initiated requests must also be associated with an active client request. That makes interactions easier to reason about from both an infrastructure and security perspective.

MCP is becoming easier for gateways to understand

Modern MCP requests can expose routing information in HTTP headers, including information about the MCP method being invoked. An API gateway or rate limiter can therefore make decisions without parsing every JSON-RPC body.

For infrastructure teams, this opens the door to conventional routing, observability, quotas, rate limiting and traffic analysis.

Google's Apigee work illustrates that direction: gateway infrastructure can expose operations from an OpenAPI specification as MCP tools and handle protocol translation rather than requiring a completely separate MCP stack.

Security is becoming a first-class deployment concern

Scaling MCP is only useful if access to tools can also be controlled safely.

The 2026 work includes authorization hardening around OAuth and OpenID Connect concepts, including stronger issuer validation, credential isolation and scope handling.

The wider ecosystem is also adding administrative controls around which MCP servers can be used. GitHub, for example, introduced enterprise MCP allowlists in August 2026 so administrators can centrally control MCP servers used by supported GitHub Copilot clients.

MCP servers may expose databases, deployment systems, business applications or other privileged capabilities to an AI agent. Authentication, authorization, tool permissions and auditability therefore belong in the architecture.

Do existing MCP servers need to be rewritten?

Not necessarily.

The transition is supported by official SDKs. Implementations can support modern traffic while retaining compatibility behavior for clients from the earlier protocol era, allowing gradual rather than flag-day migration.

A sensible migration strategy is to determine whether an existing MCP server actually depends on protocol sessions. Conventional request/response tools may be straightforward to migrate. Session-scoped data, subscriptions or older server-to-client behavior may require more architectural work.

What developers should review now

If you maintain an MCP server, audit five areas.

First, identify application data stored implicitly against an MCP session and determine whether it should instead have an explicit application identifier.

Second, check your MCP SDK version and support for the 2026-07-28 protocol revision.

Third, review server-to-client interactions and adopt the newer round-trip model where required.

Fourth, review authentication and authorization rather than treating protocol migration as a transport-only change.

Finally, test behind more than one application instance. Consecutive requests should safely reach different instances.

MCP is becoming infrastructure, not just a developer protocol

MCP began as an interoperability layer between models and external capabilities. It is now being adopted across AI development tools, cloud platforms and agent ecosystems.

Google has integrated MCP into developer products and APIs, while OpenAI's Apps SDK is built on MCP to combine external tools and data with interactive experiences inside ChatGPT.

As adoption expands, MCP infrastructure has to support workloads very different from the local integrations for which early implementations were optimized.

Making the protocol core stateless is therefore an important maturation step.

For developers, the takeaway is simple: an MCP server should increasingly be designed like a scalable web service, with explicit application state, clear authorization boundaries and infrastructure that does not depend on one long-lived protocol session.

That makes MCP less unusual to operate—and considerably more practical for the next generation of production AI agents.