AWS Builder Center

MCP went stateless. Is your AWS deployment still well-architected?

On July 28, 2026, the Model Context Protocol became stateless, its biggest change since launch. Learn what that means for MCP servers on AWS: the deployment patterns you no longer need, a pillar-by-pillar Well-Architected review, and a migration checklist.

The 2026-07-28 release removes the session workarounds that remote MCP deployments needed until now. Here's the Well-Architected review of what changed and how to respond.
The Model Context Protocol (MCP) has become the standard way to connect AI agents to tools and data. Published on July 28, 2026, the specification is  the protocol's biggest change since it launched : the protocol core becomes stateless, extensions become a formal mechanism, and a deprecation policy governs everything going forward. It is a deliberate breaking release. One thing to settle up front, because it drives everything else: stateless here means the protocol, not your application. Your stateful use cases still work; the state just moves into the open, as we will see.
If you run MCP servers on AWS, this release lets you remove infrastructure that the previous protocol required, and it changes the deployment patterns that made sense until now. This post walks through what changed, why, and what to do about it, through the Well-Architected pillars and the guidance AWS already publishes for agentic systems in the  Agentic AI Lens .
Who should read this:
  • Server builders: your session handling, tool schemas, and long-running work patterns change.
  • Client and host builders: version negotiation, authorization, elicitation, and error handling change.
  • Platform and gateway teams: routing, caching, throttling, and tracing all get simpler, but only if you adopt the new mechanisms.



How we got here

A short version history, because the debt story only makes sense if you see how it accumulated. Each release added capability. None of them changed the foundation.
Version
What it introduced
2024-11-05
The initial release. Designed for local use: a desktop app talking to a tool server on the same machine over stdio.
2025-03-26
MCP goes remote. Streamable HTTP transport and an OAuth 2.1 authorization framework.
2025-06-18
MCP grows up as an API: elicitation (a standard way for a server to ask the user for structured input through the client, like confirming a deletion before a tool proceeds), structured tool output, and OAuth resource indicators (RFC 8707).
2025-11-25
MCP goes enterprise: experimental Tasks for long-running work, Client ID Metadata Documents (CIMD), and enterprise-managed authorization.
2026-07-28
The clean break. Stateless core, formal extensions, MCP Apps, hardened authorization, deprecation policy.
The pattern to notice: MCP was born as a local protocol, where a persistent connection between one client and one server is free. Every release after that stretched the same session-based design further into remote, multi-instance, enterprise territory. It worked, but the stretch marks showed.

The architectural debt

By late 2025, running MCP at production scale meant working around the protocol, not with it. Four problems kept coming up:
1. Sessions fought horizontal scaling. Every connection started with a mandatory  initialize  handshake, and servers could issue an  Mcp-Session-Id  (a session token the client had to send on every later request), expecting the server to remember it. On ECS or EC2, that meant the instance that issued a session had to receive all its requests. Deployment guides said it plainly:  enable target-group stickiness . On Lambda, where there is no instance to stick to, builders externalized session state to DynamoDB or ran session-free "stateless modes", though even those still carried the mandatory handshake and its connection-scoped state. Tellingly,  AWS's own ECS walkthrough  ran in stateless mode precisely to avoid session affinity. When the options are "pin clients to instances," "add a database to hold sessions," or "avoid the feature," the design is the problem.
A mental model: the old protocol was a phone call. You dial, say hello, and the person on the other end has to stay on the line and remember everything you said. The new protocol is postcards: every message carries everything needed to act on it, and any clerk at the post office can process it.
2. No UI story, so everyone invented one. Demand for interactive interfaces did not wait for a standard: the community MCP-UI project and OpenAI's Apps SDK filled the gap in incompatible ways ( SEP-1865  documents this lineage). A server's tools ran in any MCP host (the app the user talks to: Amazon Quick, Claude, ChatGPT), but its UI worked in only one, and each workaround invented its own trust model for server-supplied HTML running inside the host app. The missing feature was a gap; the incompatible workarounds were the debt.
3. No formal way to extend or retire anything. Versioning marks when things change; there were no rules for how a feature enters or leaves the protocol. Extensions existed informally but had no governance (no registry, no negotiation rules, no independent versioning), and no deprecation policy guaranteed a migration window before something disappeared. Every improvement faced a bad binary: push it into the core spec, or break the people who built on it. Tasks is the cautionary tale: it shipped in the core as experimental because there was nowhere else for it to live, and everyone who adopted it now migrates to its redesign.
4. Authorization was loosely specified. OAuth assumes a client preconfigured with one known authorization server; MCP is one client meeting many servers dynamically, and the 2025 spec did not pin down how OAuth behaves in that pattern. Real deployments hit the gaps constantly: desktop clients rejected because authorization servers assumed they were web apps, no required defense against authorization-server mix-up attacks, and undocumented refresh token behavior forcing users to log in repeatedly.

The 2026-07-28 release: a deliberate clean break

The maintainers chose to break the protocol once, on purpose, to fix the foundation, and to pair the break with governance so it never has to happen again. Three mechanisms back that promise:
  • A feature lifecycle policy: every feature is Active, Deprecated, or Removed, with at least twelve months between deprecation and removal. This release exercises it immediately: Roots, Sampling, and Logging are deprecated today, guaranteed to keep working for at least a year, and removing them will require a separate proposal.
  • An extensions framework: new capabilities ship as opt-in extensions and prove themselves there before touching the core spec. Tasks shows why this matters: it shipped experimental inside the core, needed a redesign, and forced a migration on everyone who adopted it. Under the framework, that churn happens in an extension that only volunteers carry.
  • A conformance requirement: no proposal reaches Final status without a matching scenario in the conformance test suite. Before, two SDKs could read the same spec sentence differently and both claim compliance; now the expected behavior ships as an executable test, the same suite official SDKs are scored against.
The practical impact: building on MCP becomes a predictable investment. You pay the migration cost once, and in return what you depend on cannot disappear without a documented path out and, barring an expedited exception, at least a year of notice. That predictability is exactly what platform teams and enterprises need before they standardize on a protocol.
The headline change is the stateless core, and it removes both pieces of ceremony from the debt section. The  initialize  handshake is gone: a client no longer opens with an exchange of versions and capabilities before it is allowed to do anything. The  Mcp-Session-Id  header is gone: the server no longer issues a token that ties a client to one instance. In practice, the very first message a client sends can be the actual tool call. Every request is self-contained: protocol version and client info travel with each call, so neither side maintains a negotiated version anymore. The server simply validates each request's declared version as it arrives. A new  server/discover  method, which every server must implement, returns in a single result what the handshake used to provide: the protocol versions the server supports, its capabilities and extensions, and its identity. Clients may call it up front to pick a version, but they are not obliged to, so it is available on demand rather than being a mandatory opening step. It does not replace  tools/list , which still returns the tool catalog itself.
Note the two different kinds of removal in this release. The handshake and session header are deleted outright, with no deprecation window: they are the one-time break the governance above exists to prevent from recurring. Roots, Sampling, and Logging, by contrast, are the first features to travel the new lifecycle path, deprecated now and guaranteed to keep working for at least a year. In other words,  initialize  is the last removal that got to skip the line.
The most important thing to understand: stateless protocol does not mean stateless application.
Here is the mental model: a coat check. Under the old spec, the protocol was a valet who remembered your face; you had to keep dealing with the same valet, and nobody else could help you. Under the new spec, the coat check hands you a numbered ticket. Any attendant can serve you, because the ticket carries the reference. If your server needs state across calls (a shopping basket, a browser session, a multi-step workflow), a tool returns an identifier for that state, say a  basket_id , and the model supplies that identifier as a normal parameter on the calls that follow. The state itself stays in your datastore; the model only carries the key to it.
This turns out to be better than hidden sessions, not just equivalent. Because the reference is now a meaningful domain ID in the model's context rather than an opaque token in a header, the model can see the handle, reason about it, and pass it between tools and steps. It can even hold several at once (two baskets, three browser sessions). Session state hidden in transport metadata never allowed that. If you know REST, this is the same statelessness constraint you already follow: server keeps no per-client context, and state lives in the application, referenced by an explicit ID, rather than in the transport.
The release also includes:
  • Multi round-trip requests: instead of holding a connection open to ask the user something mid-call, the server returns an "input required" result with an opaque  requestState . The client collects the answer and re-sends the original call with the state attached. Any instance can pick it up. (Mental model: a form returned to you with a sticky note saying "missing signature, resubmit with reference #123".)
  • Routing and caching metadata: required  Mcp-Method  and  Mcp-Name  HTTP headers (the subject line on the envelope, so the mailroom can route without opening it), and  ttlMs  /  cacheScope  on list results ( ttlMs , a best-before date for how long a response stays fresh;  cacheScope , whether it can be shared across users).
  • Consolidated change notifications: the HTTP GET endpoint and  resources/subscribe  are replaced by  subscriptions/listen , one long-lived POST-response stream that a client opts into for specific notification types. Long-lived streams did not disappear from the protocol; they were reduced to this single opt-in channel, and progress or log notifications for a given request still ride that request's own response stream.
  • Standardized trace propagation: W3C Trace Context key names are now fixed in the spec, so a trace can follow a call from the host app through the client, the server, and everything downstream.
  • MCP Apps, which sits alongside this release rather than inside it: an official extension for server-rendered interactive UIs in sandboxed iframes, published earlier in 2026 (its spec is dated 2026-01-26) and versioned independently of the core protocol. It was co-developed by the MCP-UI creators with maintainers from OpenAI and Anthropic, converging the incompatible UI workarounds into one standard.
  • Tasks as an extension: long-running work moves out of the experimental core into a redesigned extension that fits the stateless model.
  • Authorization hardening: several proposals aligning MCP auth with how OAuth 2.0 and OpenID Connect actually get deployed.
  • Full JSON Schema 2020-12 for tools: composition ( oneOf ,  anyOf ,  allOf ), conditionals, and references in tool schemas.

How the new version pays down the debt, pillar by pillar

This is the Well-Architected review. Each pillar gets the questions you should ask about your MCP workload, what the new spec changes about the answers, and the new best practice to adopt, with the spec feature that enables it named alongside.

Reliability

Ask yourself: can any instance of my server handle any request? What happens to in-flight conversations when an instance is replaced?
Under the old spec, with sticky sessions an instance failure stranded every session pinned to it, and retrying elsewhere did not work because the state lived on the dead instance. Externalizing the session to a shared store avoided that, but only by adding the store you now no longer need. Either way, a request was never free to land just anywhere.
Under 2026-07-28, every request is self-contained, so:
  • Any instance can serve any request. Instance loss is a non-event.
  • Retries are safe to route anywhere and need no instance affinity.
  • Interrupted multi-step interactions are resumable: the  requestState  blob carries everything needed, so the retry can land anywhere.
  • One counterweight to plan for: stream resumability is gone. The spec removed  Last-Event-ID  replay from the transport, so if a request's response stream breaks, that in-flight request is lost and the client has to re-issue it as a new request with a new ID. Design tools to be idempotent, and treat a dropped stream as a fresh call rather than something you can resume mid-flight. The same applies to a dropped  subscriptions/listen  stream: nothing replays what you missed, so reconcile on reconnect by re-fetching the lists you care about instead of assuming every change notification arrived.
  • Scale-in no longer needs session draining. An instance can terminate the moment it finishes its in-flight requests.
The new best practice (enabled by the stateless core and multi round-trip requests): treat every MCP request as independently routable and retryable. Run identical instances behind plain round-robin, enable aggressive scale-in, and rely on  requestState  for resumable multi-step flows instead of instance affinity.

Performance efficiency

Ask yourself: am I fetching the tool list on every connection? Is my gateway parsing JSON bodies just to route requests?
  • Clients and MCP-aware gateways can now cache  tools/list  and resource reads safely, because the server declares how long a response is fresh ( ttlMs ) and whether it can be shared across users ( cacheScope ). Pushing that to a CDN like CloudFront is possible too, but not automatic: the hints live in the MCP payload, not in HTTP headers, so you map them onto HTTP caching, and account for the JSON-RPC-over-POST transport, which CloudFront does not cache (it caches only GET and HEAD).
  • The  Mcp-Method  and  Mcp-Name  headers let Application Load Balancer (ALB) listener rules, Amazon API Gateway, and AWS WAF route and throttle per operation without inspecting the body. No more deep packet inspection to tell a  tools/list  from a  tools/call .
The new best practice (enabled by the routing and caching metadata): note that  ttlMs  and  cacheScope  are required on list and resource-read results, not optional, so treat setting them deliberately as a conformance matter rather than an optimization. Return tools from  tools/list  in a deterministic order too, which the spec recommends because stable ordering improves both client-side caching and LLM prompt cache hits. Then make routing and throttling decisions at the gateway from headers, never from parsed bodies.

Cost optimization

Ask yourself: what am I paying for that exists only to work around protocol sessions?
This pillar is where the release shows up on your bill, though the savings land only once you stop serving legacy clients, since a backward-compatible lane keeps its sessions. Candidates for deletion:
  • ALB sticky sessions and the uneven load distribution they cause.
  • The session store: the DynamoDB table or ElastiCache cluster whose only job was holding  Mcp-Session-Id  state.
  • Overprovisioning driven by session pinning (hot instances that happened to hold long sessions).
  • Held-open connections: elicitation no longer requires keeping an SSE stream alive, which matters directly on Lambda where you pay for duration.
To make this concrete, an illustrative example rather than a benchmark. The saving depends on which session approach you took. If you externalized state, you were paying for the store: a two-node  cache.t4g.micro  ElastiCache pair for resilience comes to about $23 per month, from two nodes at $0.016 per hour on demand over 730 hours, per the AWS Pricing Calculator in July 2026. Add the CloudWatch alarms, IAM roles, and networking around it. Going stateless deletes that whole line, and your own figure will move with region, cache engine, and node count. If you used sticky sessions instead, the saving is capacity: stickiness distributes load unevenly, so you over-provisioned to absorb the hot instances holding long-lived sessions, and any-instance routing now lets you pack tighter and scale in sooner. Either way the shape is the same at every scale: a cost driver leaves the architecture, and the remaining fleet runs closer to its real utilization.
Lambda deserves a special mention. The old protocol was an awkward fit for Lambda, because Lambda has no sticky routing and no persistent connections; running a session-based server meant externalizing the session to a shared store, and even a session-free "stateless mode" still paid for the mandatory handshake. The new protocol's request/response shape is exactly what Lambda does natively. Serverless MCP just became a first-class pattern instead of a workaround.
The new best practice (enabled by the stateless core): audit your architecture for anything that exists only to preserve sessions, and delete it. If your tools need cross-call state, hold it as application data keyed by an explicit handle, priced and scaled like any other application data.

Security

Ask yourself: do I validate where my authorization responses come from? Can my server prompt a user when nothing is in flight?
  • Clients must validate the  iss  parameter (the issuer identifier that says which authorization server produced a response) on authorization responses, per RFC 9207, closing a mix-up attack path that MCP's one-client-many-servers pattern makes more likely. If you also run the authorization server (your own OAuth service, or your configuration of Cognito, Okta, or Entra), start supplying  iss  now; future versions will expect clients to reject responses without it.
  • Clients declare their OpenID Connect  application_type , whether the client is a native or desktop app or a web app, during Dynamic Client Registration (when the client first introduces itself to an authorization server), fixing the chronic failure where desktop and CLI clients got rejected for localhost redirect URIs. Note the direction of travel here: Dynamic Client Registration itself is now deprecated in favor of Client ID Metadata Documents (CIMD), and remains only for authorization servers that do not support CIMD. Prefer CIMD for new clients and treat the registration fix as the compatibility path.
  • A server may only send a request to the client while it is actively handling a client request. That rules out unsolicited prompts: the user only sees one as the direct result of something they or their agent set in motion.
  • Registered credentials are bound to the issuing authorization server, and refresh token behavior for OpenID Connect-style servers is now documented.
The new best practice (enabled by the authorization hardening): validate  iss  on every authorization response, declare your  application_type  at registration, and treat any user prompt outside an in-flight request as a protocol violation to reject, not a quirk to tolerate.

Operational excellence

Ask yourself: can I follow one agent request end to end across my client, server, and downstream calls? Can I see per-operation metrics without custom parsing?
  • W3C Trace Context propagation ( traceparent ,  tracestate ,  baggage ) is now pinned in the spec. A request that begins in the host application can be followed as a single span tree in AWS X-Ray or any OpenTelemetry backend, across the client SDK, your server, and any downstream dependency the server invokes.
  • The  Mcp-Method  header gives you per-operation CloudWatch metrics, alarms, and WAF rules from the gateway, with no body parsing.
  • Logging via the MCP protocol is deprecated in favor of stderr (for stdio servers) and OpenTelemetry (for structured observability), which aligns MCP servers with how you observe everything else. The  logging/setLevel  method is already gone: clients now set log level per request via  io.modelcontextprotocol/logLevel  in  _meta , and servers must not emit log messages for requests that omit it.
The new best practice (enabled by standardized trace propagation and the routing headers): propagate W3C Trace Context through every MCP hop, build per-operation dashboards and alarms from the  Mcp-Method  header, and move server logging to OpenTelemetry now rather than at the end of the deprecation window.

Sustainability

Ask yourself: are you provisioning capacity for load that no longer exists?
Fewer idle held-open connections, less redundant  tools/list  traffic thanks to caching, and better bin-packing because any instance can serve any request. Stateless workloads are simply easier to run tight.
The new best practice (enabled by the stateless core): right-size aggressively. The capacity you kept warm for pinned sessions and held-open streams is no longer part of the architecture.

What this means for current AWS deployment guidance

Deployment guidance published for the session-based protocol was right for that protocol. With the protocol change, the recommended patterns change with it. This table is the migration summary:
The pattern for the session-based protocol (2025)
The pattern now (2026-07-28)
Enable ALB target-group stickiness; sessions must reach the same task
Plain round-robin. Delete the stickiness configuration.
Externalize session state to DynamoDB or ElastiCache
Delete the session store. If tools need cross-call state, use explicit handles as tool arguments.
Inspect request bodies at the gateway to route or throttle by method
Route and throttle on the Mcp-Method / Mcp-Name headers.
Lambda needs workarounds for MCP's stateful design
Lambda is a natural fit. Request in, response out.
Hold SSE streams open for server-to-client requests
Return an input-required result with requestState; the client re-sends.
Use the HTTP GET endpoint and resources/subscribe for change notifications
Opt in through subscriptions/listen, a single long-lived POST-response stream.
No standard caching story; refetch tool lists per session
Cache per ttlMs / cacheScope, optionally at CloudFront.
If you followed guidance written for the session-based protocol, whether AWS's or the broader ecosystem's, read it against this table. The patterns it recommends were correct for the old protocol and change with the protocol. Note the scope of that, though: what changes is session handling and transport (the rows above). The OAuth and OpenID Connect foundations that the same guidance describes (protected resource metadata, resource indicators, and the like) largely carry forward, since 2026-07-28 hardens that authorization model rather than replacing it. Some deployments will also have platform-specific reasons for session affinity that go beyond the protocol (for example, keeping requests on a warm instance to avoid cold starts); where that is the case, statelessness at the protocol layer and session affinity at the infrastructure layer are separate decisions.

What to be careful with

A clean break fixes debt; it also introduces new surfaces. Six things deserve caution.
1. MCP Apps put server-supplied HTML in your host. This is the biggest new security surface in the release. The spec's mitigations are real: the server registers its UI templates up front, so a host can review and cache them before anything renders; the UI itself runs in a sandboxed iframe; and any action the UI initiates is gated and logged exactly like a direct tool call, over the same JSON-RPC base protocol. But mitigations are not magic. If you build a host, treat template review as mandatory and the sandbox as one layer, not the answer. If you run an enterprise fleet, decide deliberately which servers may ship UI at all.
2. Explicit handles are visible to the model, so they are visible to prompts. The coat-check ticket is now in the model's context. Never treat a handle the model presents as proof of access. Authorization must be enforced server-side on every call: does this authenticated principal have access to this basket? A handle without a server-side ownership check is a confused-deputy vulnerability waiting to happen. Be clear about where this responsibility sits: the protocol deliberately leaves per-handle authorization to your application. It will not stop a caller from presenting an identifier they should not have, so enforcing ownership on every request is your job, not the protocol's.
3.  requestState  is a blob you hand to the client and trust to come back. Integrity-protect it (sign or MAC it), and do not put sensitive data in it unencrypted. The client echoes it back; treat the echo as untrusted input.
4.  cacheScope  mistakes leak data across users. Marking a per-user or per-tenant tool list as shareable means one tenant sees another's tools. Default to the narrowest scope and widen deliberately.
5. The dual-stack transition window doubles your surface, and defers your savings. Most fleets will run both protocol versions for a while. Two auth flows, two elicitation paths, two sets of behaviors to review. The branch is per request: a request declaring 2026-07-28 takes the modern path, while one declaring a 2025-era version, or arriving with no version at all (which is how a legacy  initialize  shows up), takes the handshake-and-session path. Note what that means for the cost story: the legacy lane keeps its sessions, so the stickiness and session store you were planning to delete have to stay until you actually stop serving old clients. Bound the window explicitly: set a date to drop 2025-11-25 support and track it.
6. Deprecated does not mean gone, but parts of it already are. The Roots, Sampling, and Logging features remain fully functional through the deprecation window, so it is easy to keep building on them. Do not. Plan the exits now: tool parameters, resource URIs, or configuration instead of Roots; direct LLM provider APIs instead of Sampling; stderr or OpenTelemetry instead of MCP Logging. And note that deprecation of the feature did not spare every method inside it:  ping ,  logging/setLevel , and  notifications/roots/list_changed  were removed outright in this release. Log level is now set per request through  io.modelcontextprotocol/logLevel  in  _meta , and a server must not emit log messages for requests that omit it.

The MCP Well-Architected review, in one page

This guidance is not a new framework. It is the MCP-specific reading of best practices that already live in the  AWS Well-Architected Agentic AI Lens , which names MCP directly in AGENTOPS04-BP02 (establish standardized tool integration protocols). The 2026-07-28 spec is what makes several of those best practices genuinely achievable for a remote MCP server, rather than something you approximate with workarounds.
Run these against your MCP workload. A "no" is a migration candidate, not a failure; it is where the new spec pays off. Each item names the enabling spec feature and the Agentic AI Lens best practice it maps to.
  • Reliability: Can any instance serve any request, and does an instance replacement leave in-flight work recoverable? (Stateless core,  requestState ; AGENTREL01-BP01 resilient messaging layer, AGENTREL07-BP02 automatic recovery from execution failures)
  • Reliability: Are retries safe without special routing? (No session affinity; AGENTREL06-BP04 idempotent task execution patterns)
  • Performance: Are your list responses cacheable, with  ttlMs  and  cacheScope  set deliberately? (Caching metadata; AGENTPERF03-BP04 efficient caching and data access patterns)
  • Performance: Does your gateway route and throttle from headers rather than parsed bodies? ( Mcp-Method  /  Mcp-Name ; AGENTPERF04-BP02 efficient protocol-based communications, AGENTPERF07-BP02 tenant-aware isolation and throttling)
  • Cost: Is anything in your architecture there only to preserve sessions? (Stateless core; AGENTCOST04-BP02 cost-optimize tool serving through serverless and resource sharing)
  • Security: Do clients validate  iss  on authorization responses and declare  application_type ? (Authorization hardening; AGENTSEC03-BP01 strong authentication for agent identities)
  • Security: Is every server-to-client prompt tied to an in-flight request? (Elicitation rules; AGENTSEC04-BP01 guardrails and alignment controls)
  • Security: Is access checked server-side per handle, never trusting a handle the model presents? (Explicit-handle pattern; AGENTSEC02-BP01 tool authorization, AGENTSEC03-BP02 separate agent and human permission)
  • Operational excellence: Does W3C Trace Context propagate through every MCP hop, with per-operation metrics? (Trace Context, routing headers; AGENTOPS05-BP01 end-to-end tracing and telemetry, AGENTOPS05-BP03 structured logging and audit trails)
  • Sustainability: Have you right-sized away the warm capacity that pinned sessions required? (AGENTSUS02-BP03 appropriately scale compute dependencies)
The base Well-Architected Framework backs the same moves: horizontal scaling and elastic capacity ( REL07-BP01 ), caching data-access patterns ( PERF03-BP05 ), and least-privilege permissions ( SEC03-BP01 ).

Call to action: your migration path

First, the question everyone should ask: do you have to migrate at all?
Not immediately. Spec versions are frozen snapshots, and a client and server have to share a version to talk, so servers on 2025-11-25 keep working with every client that still speaks it. Nothing breaks in place. Migration is a value decision, and for some workloads (a local stdio server, for example) there is no urgency at all.
But "stay" is not a stable state. Hosts decide how long they keep speaking 2025-11-25, and there is no formal guarantee about that window; when major hosts drop it, an unmigrated remote server becomes unreachable for their users. SDK attention concentrates on the new version. And 2025-11-25 is now Final, meaning frozen forever: every new capability and every future improvement, including to authorization, lands on 2026-07-28 or later. Plan your migration on your own schedule, but know that the schedule has an ecosystem-imposed horizon.
For those ready to move: the ecosystem is not waiting. GitHub's MCP Server  shipped support ahead of the release , and the final specification is now live, with the official TypeScript and Python SDKs shipping 2026-07-28 support in their v2 releases. Here is the checklist by situation.
Building a new server?
  • Target 2026-07-28 directly. There is no reason to take on the old model's debt.
  • Design stateless from the start: explicit handles, no session assumptions.
  • Do not build on Roots, Sampling, or MCP Logging.
  • Use the Tasks extension for long-running work and full JSON Schema 2020-12 for expressive tool contracts.
Migrating an existing server? In order:
  1. Upgrade the SDK and  opt in to 2026-07-28 . The SDK handles the wire-level changes (handshake removal, headers,  _meta  propagation). Speaking the new version is an explicit opt-in, not automatic.
  1. Audit for session assumptions. Anywhere your code expects state to survive between calls without an explicit handle, refactor to the coat-check pattern.
  1. Migrate off the experimental Tasks API if you used it; the extension's lifecycle is different, and  tasks/list  is gone.
  1. Plan the deprecation exits for Roots, Sampling, and Logging within the twelve-month window.
  1. Fix the small stuff: clients matching on error code  -32002  should match  -32602 ; authorization servers should emit  iss .
  1. Then collect the savings: remove stickiness, delete the session store, add header-based routing and WAF rules, enable caching, wire up Trace Context.
Building a client or host?
  • Send the protocol version and client info on every request; drop the  initialize  handshake dependency.
  • Validate  iss  on authorization responses and declare your  application_type  at registration.
  • Move elicitation to the multi round-trip flow, echoing  requestState  back on the follow-up call. The  notifications/elicitation/complete  notification and the  elicitationId  field are gone, so a server that needs to correlate an out-of-band interaction across retries encodes its own identifier in  requestState .
  • Drop any dependence on  ping ,  logging/setLevel , and  notifications/roots/list_changed , all removed in this release, and set log level per request in  _meta  instead.
  • Update error matching from  -32002  to  -32602 , and pick up the renumbered MCP codes under the new allocation policy:  HeaderMismatch  moves to -32020,  MissingRequiredClientCapability  to -32021, and  UnsupportedProtocolVersion  to -32022. Honor  ttlMs  /  cacheScope  when caching list results.
  • Handle  UnsupportedProtocolVersionError  by retrying with a version the server lists, and treat results from older servers that omit  resultType  as complete.
Running a platform or gateway?
  • Add  Mcp-Method  /  Mcp-Name  routing, per-operation throttling, and metrics.
  • Respect  ttlMs  /  cacheScope  in any caching layer.
  • Check your idle timeouts against  subscriptions/listen . It is the only stream designed to stay open indefinitely, so if servers in your fleet use it, the load balancer, proxy, and compute tier all need to tolerate a held-open POST response.
  • Propagate W3C Trace Context.
  • Decide your policy for MCP Apps before the first server in your fleet ships one.
Validate before you trust it. The official conformance suite covers the new behaviors (it is the same suite SDKs are scored against), and protocol inspectors can pin the 2026-07-28 version to test your server against exactly what clients will send.
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article