SEP-2575 Explained: How Stateless MCP Changes AI Architecture

MCP Spec Breakthrough: How SEP-2575 & Stateless Tools Change AI Architecture

A production engineer's guide to the biggest revision in Model Context Protocol history

Quick Answer: SEP-2575 is the Specification Enhancement Proposal that removes MCP's mandatory initialize/initialized handshake, the piece of the protocol that forced every MCP connection into a stateful, sticky-routed session. Paired with SEP-2567 (which removes the Mcp-Session-Id header), it makes every MCP request self-contained: protocol version, client info, and capabilities now travel in _meta on each call. The practical result is that MCP servers can finally sit behind a plain round-robin load balancer, scale horizontally like any ordinary HTTP service, and drop the sticky-session infrastructure that made production MCP deployments painful. This ships as part of the MCP 2026-07-28 specification, expected to go final on July 28, 2026.

Quick Summary

What changed	MCP's protocol-level session (handshake + session ID) is removed; every request is now self-describing
Why it matters	MCP servers can be load balanced, auto-scaled, and cached the same way any stateless HTTP API can
Who benefits	Platform engineers, agent developers, enterprise architects running MCP servers in production at scale
Key improvements	Stateless core, server/discover, routable headers, formal deprecation policy, OAuth-aligned auth
Reading time	18–22 minutes
Difficulty	Intermediate to advanced (assumes basic MCP familiarity)

Table of Contents

1. Why SEP-2575 Is the Biggest MCP Change
2. What Is SEP-2575?
3. The Coat-Check vs. the Claim Ticket
4. Before vs. After
5. How Stateless MCP Works
6. MCP Request Flow
7. Why This Changes AI Architecture
8. Real-World Examples
9. Performance Benefits
10. Security Implications
11. Comparison Table
12. Implementation Roadmap
13. Common Migration Challenges
14. Case Study
15. Future of MCP
16. Career Opportunities
17. Common Beginner Mistakes
18. Expert Tips
19. FAQ
20. Conclusion

Picture a Tuesday deploy review. An enterprise platform team has 100 MCP servers running behind what is supposed to be a standard load balancer, fronting a fleet of internal tool-calling agents used by every engineering org in the company. The rollout looked simple on the architecture diagram. In production it wasn't.

Every MCP session opens with an initialize handshake. The server that answers that handshake becomes the server that owns the session state for the rest of the conversation — tool capabilities, negotiated protocol version, client identity, all of it pinned to one instance via an Mcp-Session-Id header. So the load balancer can't actually load balance. It has to route on session affinity, which means either sticky sessions (and the failover headaches that come with them) or a shared session store that every instance has to read and write on every call, adding a network hop and a new source of latency to a system that's already chaining LLM calls, tool calls, and downstream APIs.

Scale that to 100 servers and the operational cost stops being theoretical. A single instance restart drops every session pinned to it. Autoscaling has to account for session distribution, not just CPU. Multi-region failover means replicating session state across regions or accepting that a regional outage kills every in-flight agent conversation routed there. None of this is exotic — it's the same sticky-session tax that stateful services have always paid — but it's a strange tax for a protocol whose entire job is to sit in front of stateless HTTP tools.

SEP-2575 is the proposal that removes the reason this tax exists. It deletes the mandatory handshake, and its companion proposal, SEP-2567, deletes the session ID that the handshake produced. Together they're the foundation of the MCP 2026-07-28 specification — the largest revision to the protocol since it launched, expected to go final on July 28, 2026. This piece walks through what changed, why it matters architecturally, and what a real migration looks like.

Why SEP-2575 Is the Biggest MCP Change

To see why this is a bigger deal than a routine protocol tweak, it helps to be precise about what the old architecture actually required.

Session-based MCP. The 2025-11-25 specification (the version most production MCP servers run today) treats a connection as a conversation with memory. The client sends initialize, the server responds with its capabilities and hands back an Mcp-Session-Id, and the client echoes that ID on every subsequent request for the life of the connection. The server is expected to remember the negotiated protocol version and capabilities for that session without the client repeating them.

The scaling problems this creates:

• Sticky sessions — the load balancer has to inspect the session ID and consistently route to the same backend instance, which defeats the point of having a load balancer decide dynamically
• Shared state stores — the alternative to sticky routing is a Redis-like session store every instance queries, adding latency and a new dependency that has to be highly available
• Fragile failover — if the instance holding a session dies, every in-flight agent task tied to that session dies with it, with no clean recovery path at the protocol layer
• Horizontal scaling friction — adding instances doesn't linearly add capacity, because new instances can't serve existing sessions; they can only take new ones

SEP-2575 solves this at the root rather than patching around it. Instead of a stateful handshake that has to happen once and then be remembered, the SEP embraces what its authors call a "pay as you go" model: every request carries everything the server needs to understand it — protocol version, client identity, capabilities — without depending on anything the server remembers from an earlier call. Any request can now land on any instance. That's the entire scaling problem, solved by making the problem impossible rather than manageable.

Related reading: if you're deploying MCP servers across regions or hybrid infrastructure, this pairs directly with our guide to Sovereign AI and hybrid cloud architecture.

What Is SEP-2575?

SEP-2575 ("Make MCP Stateless") is a Specification Enhancement Proposal in the Model Context Protocol's formal SEP process, migrated to the current PR-based format from an earlier issue-based discussion. It carries Final Standards Track status as part of the 2026-07-28 specification release candidate.

Purpose and design goals: the proposal's own framing is that a truly stateless protocol — where every request is self-contained and can be understood in isolation — is inherently simpler, more scalable, and more reliable than one that depends on connection-scoped memory. Rather than removing statefulness as a blanket rule, it proposes a layered model: simple, stateless behavior by default, with the overhead of long-lived state introduced only where an application genuinely needs it.

Protocol changes it introduces:

• Removes the initialize/initialized handshake entirely
• Requires the protocol version on every request, via an MCP-Protocol-Version HTTP header that must match the value in the request's _meta field — mismatches return a 400 Bad Request
• Introduces a new server/discover RPC method, an optional call clients can use to fetch server capabilities, supported versions, and metadata up front, replacing the capability exchange that used to happen inside initialize
• Leaves session management itself to two sibling proposals — SEP-2322 and SEP-2567 — so this SEP focuses narrowly on removing the handshake and providing stateless alternatives for version negotiation, discovery, and capability exchange

Engineering philosophy: the proposal is explicit that a stateless protocol core does not mean stateless applications are mandatory. If a server genuinely needs to track something across calls — a shopping cart, a browser session, a long-running deployment — it can do what ordinary HTTP APIs have always done: mint an explicit handle (a basket_id, a browser_id) from a tool call, and have the model pass that handle back as a normal argument on later calls. State moves from the transport layer, where it was invisible and fragile, to the application layer, where it's visible, composable, and something the model can reason about directly.

Enterprise impact: removing protocol-level session dependence means standard infrastructure — round-robin load balancers, HTTP-layer caching, ordinary autoscaling groups — works with MCP the way it works with any other web service, without MCP-specific routing logic at the gateway.

The Coat-Check vs. the Claim Ticket

Think about two ways a restaurant can handle your coat.

Old MCP is a coat-check attendant with a memory. You hand over your coat, the attendant remembers your face, and later you walk up and they recognize you and fetch your coat. It works — until that attendant goes on break. Now nobody else on staff knows which coat is yours, because the knowledge lived in one person's head, not on the coat itself.

Stateless MCP is a numbered claim ticket. You hand over your coat, get a ticket with a number, and that ticket is all that matters. Any staff member — the one who checked you in, or someone who just started their shift five minutes ago — can read the number and hand you the right coat. The knowledge lives on the ticket, not in anyone's memory.

SEP-2575 turns MCP from the first model into the second. The "ticket" is the request's own metadata — protocol version, identity, and any application state the server chose to hand back as an explicit value. Any server instance can read it and act correctly, which is exactly what a round-robin load balancer needs to be true.

Before vs. After

Old MCP (2025-11-25)	New MCP (2026-07-28, SEP-2575 + SEP-2567)
Stateful — session established via handshake	Stateless — every request is self-contained
Sticky sessions required at the load balancer	Standard round-robin load balancer works out of the box
Complex scaling — session distribution matters as much as CPU	Horizontal scaling — any instance serves any request
Shared session store often required across instances	No session store — application state travels as explicit handles
Difficult failover — instance death loses in-flight sessions	Simple routing — instance death loses nothing session-related
MCP-aware gateway logic needed to route correctly	Cloud-native by default — treated like any HTTP service

How Stateless MCP Works

The mechanics are simpler than the old handshake flow, not more complex — that's the point.

• Client: constructs each request as a complete, self-describing unit. No prerequisite handshake call needed before a tool call can be made.
• Headers: the MCP-Protocol-Version HTTP header is mandatory on every request and must match the version declared in the payload's _meta field, or the server returns a 400. New Mcp-Method and Mcp-Name headers let gateways route and rate-limit based on the operation being called, without parsing the JSON body at all.
• Metadata (_meta): carries the protocol version, client info, and client capabilities that used to be exchanged once in initialize. This is what makes the request self-contained — a server instance that has never seen this client before can still process the call correctly.
• Tool Call: executes exactly as before at the tool level — the difference is entirely in how the surrounding envelope is constructed, not in tool semantics.
• Server: validates headers against _meta, processes the call, and — if the tool needs to preserve state for a later call — returns an explicit handle in the response rather than storing it in a session.
• Response: a normal JSON-RPC response; if the operation is long-running, it can now return a task handle instead of a final result, driven onward with tasks/get, tasks/update, and tasks/cancel rather than holding a connection open.
• Load Balancer: routes on ordinary HTTP semantics — round robin, least connections, whatever the platform already uses for other services — with no MCP-specific affinity logic required.
• Caching: because requests are self-contained and tools/list responses can now carry a ttlMs value, clients and intermediate proxies can cache tool metadata for a bounded, server-specified window instead of re-fetching it every session.

The role of headers and metadata here is doing real architectural work: they're what let infrastructure that knows nothing about MCP's internal semantics — a generic L4/L7 load balancer, a CDN cache — still route and cache MCP traffic correctly, because everything they need is visible without understanding the protocol.

MCP Request Flow

User → LLM → MCP Client → Load Balancer → Stateless MCP Server (any instance) → Tool → Response

Walking through each hop:

1. User issues a request in natural language to an agent or assistant.
2. LLM interprets intent and decides a tool call is needed, producing a structured call.
3. MCP Client packages that call as a self-contained request — protocol version, identity, and any state handles included in _meta and headers — with no dependency on a prior handshake.
4. Load Balancer picks any healthy MCP server instance using ordinary routing logic; it does not need to know or care which instance served the previous request.
5. Stateless MCP Server validates the request's headers against its _meta, and because the request is fully self-describing, any instance can process it correctly.
6. Tool executes — this is unchanged from earlier MCP versions; the tool's own logic doesn't need to know the protocol went stateless.
7. Response returns to the client, potentially carrying an explicit state handle for the next call, or a task handle if the operation is long-running.

Compare this to the old flow, where step 4 required session-aware routing and step 5 required the receiving instance to already hold that session's state — the two steps that made horizontal scaling hard are exactly the two steps this revision simplifies.

For a deeper look at where MCP fits in a broader agent toolchain, see our roundup of the top open-source MCP servers AI engineers are running in production.

Why This Changes AI Architecture

Statelessness isn't a cosmetic protocol cleanup — it's an alignment fix. Most of the infrastructure AI teams already run was built around stateless-by-default assumptions, and MCP's old session model was the odd one out.

• Microservices & containers: a stateless MCP server is just another container that can be killed, restarted, and rescheduled by an orchestrator without coordination logic to preserve session affinity.
• Kubernetes: pods can be added or removed by the HPA (Horizontal Pod Autoscaler) based purely on load, since no pod is "special" by virtue of holding sessions other pods don't have.
• Serverless & edge AI: functions that spin up per-request were always awkward with session-based MCP, since cold starts couldn't inherit session state; a stateless core removes that mismatch entirely.
• Distributed agents: multi-agent systems that fan requests out across many MCP tool servers no longer need a coordination layer just to keep sessions consistent across that fan-out.
• Hybrid and multi-region deployments: requests can be served from whichever region is closest or healthiest, because no region "owns" a client's session state.

The common thread: cloud-native infrastructure has spent a decade optimizing for stateless services. SEP-2575 doesn't invent new infrastructure patterns for MCP — it removes the reason MCP needed to be treated differently from everything else already running in that infrastructure.

Real-World Examples

Enterprise SaaS

Problem: a multi-tenant SaaS platform running MCP-based copilots for thousands of customers needed sticky routing per tenant, complicating tenant isolation. Old MCP: session affinity tied to tenant, risking noisy-neighbor effects on shared instances. New MCP: any instance serves any tenant's stateless requests; tenant isolation happens at the auth layer instead. Business impact: simpler capacity planning and fewer tenant-specific routing rules to maintain.

Healthcare

Problem: clinical decision-support agents need high availability with strict audit trails. Old MCP: a lost session mid-consultation meant a lost audit context. New MCP: explicit state handles carry patient-session context as auditable, model-visible arguments rather than hidden connection state. Business impact: cleaner compliance trails and no single-instance dependency during a consultation.

Finance

Problem: trading and risk agents run on infrastructure with strict failover SLAs. Old MCP: instance failure mid-session could interrupt a risk calculation with no clean resume path. New MCP: any surviving instance can pick up the next request immediately, since no instance is a single point of session failure. Business impact: tighter alignment with existing financial-services HA requirements.

Developer Platforms

Problem: IDE-integrated agents (Claude Code, Cursor-style tools) making frequent, short-lived tool calls paid a disproportionate handshake tax per session. Old MCP: handshake overhead on every new connection from a CLI or editor plugin. New MCP: no handshake at all — the first request is already fully functional. Business impact: lower latency on the exact workflows developers feel most directly.

Cloud AI Platforms

Problem: hosting providers offering "MCP server as a service" needed per-customer sticky infrastructure. Old MCP: session pinning limited how densely tenants could be packed onto shared compute. New MCP: standard autoscaling groups and round-robin load balancers, the same primitives used for any other hosted API. Business impact: better compute density and simpler hosting economics.

Government

Problem: public-sector deployments often require strict, auditable infrastructure with minimal custom routing logic (fewer components to certify). Old MCP: sticky-session gateways were a nonstandard component requiring separate security review. New MCP: standard load balancers already covered under existing infrastructure certification. Business impact: a smaller bespoke attack surface to audit and approve.

Manufacturing

Problem: edge-deployed agents on factory floor hardware need to survive intermittent connectivity and instance restarts without losing in-progress tool workflows. Old MCP: a dropped connection meant a dropped session and a restarted workflow. New MCP: explicit handles mean a reconnect can resume exactly where it left off, since state lives in the handle, not the connection. Business impact: more resilient automation on unreliable edge networks.

Performance Benefits

• Scalability: horizontal scaling becomes linear — adding instances adds capacity without session-distribution overhead.
• Latency: no handshake round-trip before the first useful call; short-lived connections (typical of CLI tools and edge functions) benefit the most.
• Caching: the new ttlMs field on tools/list responses lets clients cache tool metadata for a bounded window instead of re-fetching every session.
• High availability: instance failure no longer takes in-flight sessions down with it, since there's no session to lose.
• Auto-scaling: autoscalers can react to load alone, without accounting for where sessions currently live.
• Resource utilization: no idle capacity reserved on session-holding instances that happen to be underused otherwise.
• Deployment simplicity: standard blue-green and canary deployment patterns work without special session-draining steps.

Security Implications

The same release candidate that ships the stateless core also ships a meaningful hardening of MCP's authorization model, and the two are related: once you stop relying on a session to imply trust, authorization has to be proven on every request instead.

• OAuth 2.1 / OpenID Connect alignment: several SEPs in this revision bring MCP's authorization flow closer to mainstream OAuth deployments rather than the more ad hoc "bring your own token" pattern of earlier versions.
• iss parameter validation (per RFC 9207): future clients are expected to reject authorization responses that omit the issuer parameter, closing a class of mix-up attacks between authorization servers.
• Resource Indicators (RFC 8707): required in token requests, scoping tokens more tightly to the resource they're meant for.
• application_type in Dynamic Client Registration: authorization servers stop defaulting desktop and CLI clients to "web" behavior, which used to cause spurious rejections of localhost redirects.
• Scope accumulation on step-up: lets a client request additional scopes mid-flow rather than re-authenticating from scratch.
• Credential binding to the issuing authorization server: reduces the risk of tokens being replayed against a server that didn't issue them.
• Zero Trust posture: because no request can lean on implicit session trust, every call is authenticated and authorized independently — which is a more natural fit for zero-trust network models than the old session-implies-trust pattern.
• API Gateway alignment: the new Mcp-Method and Mcp-Name headers let a gateway apply least-privilege policy per operation without needing to parse the JSON-RPC body.

Comparison Table

Dimension	Stateful MCP (2025-11-25)	Stateless MCP (SEP-2575)	REST APIs	gRPC
Scaling	Requires sticky routing	Standard horizontal scaling	Standard horizontal scaling	Standard, connection-multiplexed
Complexity	Higher — session lifecycle to manage	Lower — pay-as-you-go state	Low, well understood	Moderate — schema/codegen overhead
Reliability	Session loss on instance failure	No session to lose	High, mature tooling	High
Deployment	Needs session-aware gateway	Deploys like any HTTP service	Simple	Needs HTTP/2 infra
Cloud readiness	Poor fit for autoscaling	Native fit for containers/serverless	Native fit	Native fit, higher perf ceiling

If you're deciding how MCP fits alongside your existing tool-calling stack, our comparison of how Claude Code and Cursor are changing software architecture is a useful companion read.

Implementation Roadmap

Week 1 — Understand Stateless MCP: read the SEP-2575 and SEP-2567 text, diff a stateful vs. stateless sample server, and identify every place your current server assumes session continuity.

Week 2 — Build a Local Server: stand up a minimal server on a beta Tier-1 SDK (Python v2 or TypeScript v2), replace any session-scoped state with explicit handles passed as tool arguments.

Week 3 — Deploy Behind a Load Balancer: run multiple instances behind a plain round-robin load balancer with affinity disabled, and run your full test suite — any failure signals a hidden session dependency.

Week 4 — Production Hardening: add the new routable headers, validate iss parameters on auth responses, set ttlMs on tool metadata, and confirm your deprecation plan for Roots, Sampling, and Logging.

Common Migration Challenges

• Session removal: code that implicitly relies on session-scoped variables needs to be rewritten to pass state explicitly through tool arguments.
• Legacy SDKs: Tier 1 SDKs get a 10-week window to ship support; anything on an older SDK version needs an explicit upgrade plan before the final spec lands.
• Authentication: teams that leaned on session identity as an implicit auth signal need to move to per-request token validation.
• Caching: tool metadata caching now depends on respecting server-supplied ttlMs values rather than assuming a session-scoped cache is valid for the connection's lifetime.
• Tool discovery: servers relying on the old initialize-time capability exchange need to support server/discover as the new discovery path.
• State management: the biggest mental shift — state that used to live invisibly in a session now has to be an explicit, model-visible handle.
• Backward compatibility: the 2025-11-25 spec keeps working during the transition, and clients are expected to support both wire formats — so dual-mode testing matters until the older spec is fully retired.

Case Study: A Hypothetical Enterprise Migration

The following is a hypothetical, illustrative scenario constructed for this guide — not a real company.

Old architecture: a mid-size fintech runs 40 MCP server instances behind an application load balancer with session affinity enabled, backing an internal agent platform used by support and operations teams. A shared Redis cluster holds session state for cross-instance failover, adding a dependency the team has to keep highly available in its own right.

Migration: the platform team pilots a stateless build on a single service, replacing session-held conversation context with explicit handles returned from tool calls and passed back by the client on the next turn. They disable affinity on a canary target group, run the full regression suite, and catch two tools that silently assumed session continuity — both fixed by returning an explicit context handle instead.

New architecture: all 40 instances sit behind a plain round-robin load balancer with affinity off. The Redis session store is retired entirely; any state that needs to persist across calls is now an explicit argument the model passes along, which also makes it visible in logs and easier to debug.

Lessons learned: the hardest part wasn't the protocol change itself — it was finding every place state had been implicit. Making state explicit turned out to also make debugging easier, since a request's full context is now visible in the request itself rather than reconstructed from server memory.

Future of MCP

Everything below is a reasonable extrapolation from the direction of the 2026 roadmap, not a confirmed specification behavior — it's worth reading as informed speculation rather than fact.

• Stateless AI as a default assumption: as more of the agent stack adopts stateless-by-default patterns, MCP's alignment with that norm likely accelerates adoption in enterprises that were hesitant about session-management overhead.
• Distributed agents: a stateless core makes it easier to imagine agent meshes where individual tool calls are routed dynamically across many providers and regions with no coordination overhead.
• Cloud-native AI platforms: expect more managed "MCP-as-a-service" offerings now that hosting no longer requires custom session-aware infrastructure.
• Agent platforms and multi-agent systems: the Tasks extension's handle-driven model for long-running operations is a natural fit for orchestration frameworks coordinating many agents against many tool servers.
• Hybrid cloud: statelessness removes one of the main technical obstacles to running MCP tool servers split across on-prem and cloud environments.

For more on how agent architectures are evolving, see our guide on agentic RAG vs. traditional RAG.

Career Opportunities

MCP is becoming foundational infrastructure for agentic systems the same way REST became foundational for web APIs. Engineers who understand its architecture — not just how to call a tool, but how the protocol scales, authenticates, and fails — are positioned well for the next wave of AI infrastructure roles.

Skill Area	Why It Matters
Protocol-level debugging (headers, _meta, JSON-RPC)	Most production MCP issues surface at this layer, not in tool logic
Load balancer & autoscaling configuration	Directly relevant now that MCP scales like any HTTP service
OAuth 2.1 / OpenID Connect	Core to the new authorization hardening in this spec revision
Observability (OpenTelemetry, trace propagation)	Replaces some of what session state used to make implicit
Contributing to open-source MCP SDKs	A visible, checkable way to demonstrate protocol-level fluency

Projects and portfolio ideas: migrate a small stateful MCP server to the stateless model and write up the diff; build a minimal MCP server using the Tasks extension for a long-running operation; contribute a fix or test to one of the Tier 1 SDKs' beta branches. Interview topics worth being fluent in: why sticky sessions hurt horizontal scaling, how stateless protocols push state to the application layer, and how OAuth 2.1's resource indicators reduce token misuse. We won't invent specific salary figures here — compensation for infrastructure and platform roles varies widely by region, company stage, and seniority, so check current listings for your market rather than relying on any single number.

Curious why teams are standardizing on agent-native coding tools? See why developers are switching to Claude Code.

Common Beginner Mistakes

• Using state unnecessarily: reaching for explicit handles and persistent state when a request genuinely could have been handled statelessly, adding complexity for no benefit.
• Ignoring caching: not setting or respecting ttlMs on tool metadata, forcing unnecessary re-fetches.
• Poor security defaults: assuming a request is trustworthy because "it came from the same client as before" — a session-era habit that no longer holds.
• Improper load balancer configuration: leaving sticky-session settings enabled out of habit when they're no longer needed, silently reintroducing scaling limits.
• Session assumptions in tool code: writing tool handlers that quietly depend on being called by the same instance twice in a row.
• Tool misuse: treating the new server/discover call as mandatory on every request when it's meant to be an optional, up-front discovery step.

Expert Tips

• Deployment: pin your Python package with an upper bound (e.g. mcp>=1.27,<2) before the stable v2 release ships, so you're not surprised by a breaking change.
• Scaling: disable client affinity explicitly rather than assuming it's off by default on your platform.
• Performance: use the new Mcp-Method / Mcp-Name headers for gateway-level routing decisions instead of parsing JSON-RPC bodies.
• Security: start validating the iss parameter on authorization responses now, even before your client library enforces it.
• Monitoring: wire up W3C Trace Context propagation (traceparent, tracestate) so a call can be traced end-to-end across client, server, and downstream tools in one span tree.
• Observability: log explicit state handles — since they're now visible arguments rather than hidden session data, they're a genuinely useful debugging signal.
• Cost optimization: retiring a shared session store (Redis or similar) is often the single biggest infrastructure cost removed by this migration.

Frequently Asked Questions

What exactly does SEP-2575 remove from MCP?

It removes the mandatory initialize/initialized handshake that every MCP connection used to require before any tool calls could happen.

Is SEP-2575 the same thing as SEP-2567?

No. SEP-2575 removes the handshake; SEP-2567 separately removes the Mcp-Session-Id header and protocol-level session. Together they deliver the fully stateless core.

Does stateless MCP mean my server can't maintain any state?

No. The protocol layer is stateless, but your application can still track state — it just does so through explicit handles passed back and forth as ordinary tool arguments, rather than hidden session memory.

When does this spec become final?

The 2026-07-28 release candidate is expected to go final on July 28, 2026, following a review window for SDK maintainers and implementers.

Will my existing MCP servers break?

The 2025-11-25 specification continues to work, and clients are expected to support both wire formats during the transition, so nothing breaks immediately — but planning a migration is worthwhile given the operational benefits.

What replaces the initialize handshake for capability discovery?

A new server/discover RPC method, which clients can call when they need to fetch server capabilities, supported versions, and metadata up front.

How does the load balancer know which instance to route to now?

It doesn't need to make a special decision at all — because every request is self-contained, any healthy instance can serve any request, so ordinary round-robin or least-connections routing works.

What are Mcp-Method and Mcp-Name headers for?

They're new required headers (from SEP-2243) that let gateways and rate limiters route MCP traffic based on the specific operation being called, without needing to parse the JSON-RPC body.

What happens to Roots, Sampling, and Logging?

They're marked deprecated under the new formal deprecation policy (SEP-2596), which guarantees at least 12 months between deprecation and removal, so they remain functional for now while migration paths (explicit parameters, direct LLM API calls, and OpenTelemetry, respectively) are adopted.

Does this affect authentication and authorization?

Yes — a separate but related set of SEPs in the same release hardens MCP's authorization model to align more closely with OAuth 2.1 and OpenID Connect, including mandatory issuer validation on authorization responses.

Is there SDK support for the new spec yet?

Beta releases for the Python, TypeScript, Go, and C# SDKs were made available covering the release candidate's core protocol changes, giving implementers a window to test before the spec goes final.

Should I migrate now or wait for the final spec?

Testing against the beta SDKs now — especially auditing your codebase for hidden session dependencies — is worthwhile, since the core protocol changes are unlikely to change substantially before the July 28, 2026 final release, and finding session-coupling issues early is far cheaper than finding them in production.

Conclusion

SEP-2575, alongside SEP-2567, is the biggest protocol-level change MCP has shipped since launch: it removes the mandatory handshake and session ID that forced production MCP servers into sticky routing and shared session stores. The result is a protocol that finally matches the stateless-by-default assumptions of the cloud-native infrastructure most teams already run.

If you're operating MCP servers at any meaningful scale — enterprise SaaS, developer tooling, edge deployments — this is worth migrating toward deliberately rather than reactively. Start by auditing your codebase for hidden session dependencies, test against the beta SDKs behind a plain load balancer, and plan your authorization hardening alongside the statelessness work, since the two are shipping together for good reason.

Next steps: read the full SEP-2575 text, pull the beta SDK for your language, and run your existing test suite behind a round-robin load balancer with affinity disabled — any failure is a session dependency worth fixing before July 28, 2026.