My Motivation
As MCP becomes the standard way our agents and internal tools talk to each other, a protocol upgrade stops being a "someday" cleanup task and becomes an operational risk. When the Model Context Protocol maintainers shipped 2026-07-28 — the largest revision since MCP launched — we had dozens of employee AI sessions and autonomous agents depending on the same MCP endpoints. A version bump that broke even one of them mid-task was not an option.
A real-world use case
Before this release, every MCP interaction opened with a handshake: the client called initialize , the server handed back a session ID, and every following call had to carry that same ID. That session pinned a client to whichever server instance issued it — scaling meant sticky sessions at the load balancer, or a shared session store, just to answer one question: which protocol version and capabilities did we agree on with this client.
We felt this directly on Amazon Bedrock AgentCore Gateway, which aggregates our Lambda tools, internal APIs, and a couple of standalone MCP servers behind one endpoint for both employee AI sessions and autonomous agents. Every one of those callers spoke MCP through the same handshake, so an upgrade meant either freezing the old version for everyone or risking an agent breaking mid-task the moment we flipped it.
The solution: a dual-version Gateway, not a cutover
MCP 2026-07-28 removes the handshake and the session entirely. Every request now carries its own protocol version, client identity, and capabilities inline — no shared state required, no sticky routing, any request can land on any server instance. That let us treat the protocol version as a single Gateway configuration field instead of a fleet-wide migration.
We added 2026-07-28 to Gateway's supportedVersions list alongside the version we were already running. One Terraform apply, and the same endpoint served both: agents that hadn't updated their client SDK kept working exactly as before, while migrated clients started getting the new stateless behavior — self-contained requests, cacheable tool lists, and Multi Round-Trip Requests for anything that needs to elicit user confirmation, instead of holding a stream open. Once telemetry showed zero traffic on the old version, we trimmed it — the same one-line Terraform change, in reverse.
The cost and operational impact
Nothing about our target Lambdas, our IAM roles, or our tool schemas changed. The migration touched exactly one field. What we removed was the operational tax that came bundled with the old handshake: no more sticky-session load balancer rules, no shared session store to provision or page on, and one fewer round trip on every single tool call an agent makes — which compounds fast once you're running hundreds of turns a day across employee sessions and autonomous workflows combined.
The bigger shift is that this is simply how protocol upgrades work for us now. Version selection happens per request, not per deployment, so the blast radius of "what if this breaks something" shrinks from every connected agent down to whichever one client we're actively testing. That's a very different risk profile than the all-or-nothing cutover the old handshake forced on us.
If you're running MCP servers behind AgentCore Gateway — or anywhere at scale — this is worth checking today: add 2026-07-28 to your gateway's supportedVersions , point one test client at it, and see the stateless behavior for yourself before you touch anything in production.
Loading article