MCP's first revision under the foundation, and the winners are not the people building servers

Bro's Sharing
, ,
1

On 28 July, MCP published the largest revision since its launch, and the first major one since Anthropic donated the protocol to the Linux Foundation’s Agentic AI Foundation last December. Most of the coverage treats it as a migration problem: what breaks, what needs patching. That reading is useful and incomplete. Read the revision as a market document instead. Match each change to its beneficiary and the split is lopsided. The gains go to whoever runs, routes and purchases MCP servers. Builders mostly get homework.

TL;DR

  1. The centre of the revision is a stateless core. A protocol that used to hold a connection open now treats every request as self-contained, which means ordinary load balancers, CDNs and existing API gateways handle MCP traffic without MCP-specific modification.

  2. The beneficiary list is a market map. Stateless favours operators, header routing favours gateways, cache rules favour CDNs, and the twelve-month lifecycle guarantee favours enterprise buyers. Builders appear almost nowhere on it. That is where the spend concentrates next.

  3. Ownership sets direction. A company can monetise a protocol’s peculiarity; a foundation only pays for it, in adoption friction. The first post-transfer revision removed the peculiarity, and AWS and Microsoft shipping support posts on launch day shows the demand side was ready.

[1] A phone call becomes the post

Old MCP behaved like a phone call. Client and server opened a connection with an initialize handshake, the server issued a session ID, and the conversation continued on that line. The constraint was architectural. Because the session lived on one server instance, every follow-up request had to reach that same instance, so scaling meant sticky sessions or a shared session store. Both are operating costs, and both are exactly the kind of workaround infrastructure teams price into a “no”.

The new revision deletes the handshake and the session. Every request carries its own protocol version, identity and capabilities, so any instance behind a plain round-robin load balancer can serve it. Mid-task questions no longer hold the line either. A server that needs user input returns an input_required result, the client gathers the answer and retries the original request with it attached, and the state in between travels inside a single opaque token. The pattern is called Multi Round-Trip Requests.

[2] Follow the gains

Match each feature to who profits and the direction of the revision stops being subtle.

The stateless core pays server operators, who scale on commodity infrastructure. The new HTTP headers such as Mcp-Method pay gateways, which now route, authorise, meter and rate-limit without opening the JSON-RPC body; Kong and Envoy do the work unmodified. The cache rules on tools/list pay CDNs and edge providers, which serve the catalogue from cache instead of refetching it on every connection. The authorisation changes, aligned with how OAuth 2.0 and OpenID Connect are actually deployed, pay enterprise security and platform teams. The lifecycle policy, which keeps deprecated features in the specification for at least twelve months, pays enterprise buyers: what you adopt today carries a written guarantee against breakage.

Run the whole list and one fact stands. The winners are not the engineers writing MCP servers. They run those servers at scale, sit in the middle of the traffic, or sign the purchase orders.

[3] This time the commoditising was done by a foundation

Every case this community has covered was a company commoditising a layer to move margin somewhere else. Microsoft released a governance kernel for free and erased the differentiation in that segment; Databricks open-sourced its coordination layer and kept the managed tier. Whoever flattened a layer had a revenue line waiting beside it.

Here the actor is a foundation, and the asset being commoditised is its own standard. Sessions and long-lived connections went; what remains runs on load balancers, caches and gateways the world already owns. The logic is straightforward once ownership is priced in. A company collects rent on a protocol’s peculiarity. A foundation collects nothing on it and pays for it in adoption friction, so it removed it. The first revision after a transfer is a fair test of what the transfer meant, and this one points in only one direction.

[4] The industry above it was already waiting

Launch-day reactions locate the demand. AWS published a post the same day explaining how AgentCore Gateway supports the new specification. Microsoft announced v2.0 of the .NET SDK and wrote that the revision is not a feature addition but a rethink of how MCP works over HTTP, adding that routing, middleware and load balancing are the concerns its stack has always been built around. Neither company ships that on launch day unless the work was staged in advance.

Put the sequence in one line. December: the standard moves to a foundation. Early July: the maintainers of its SDK start charging for operations. Late July: the specification flattens its own ground. Scale backs the sequence; by the official blog’s count, Tier 1 SDK downloads run close to half a billion a month, with the TypeScript and Python SDKs each past one billion total. The flatter the protocol, the larger the market above it.

[5] The maths for anyone running servers today

Strategy aside, teams operating MCP servers have sums to do. Stateful implementations that kept state in the session need work. They do not need it this quarter. The release candidate was locked on 21 May, went through ten weeks of validation, and shipped on schedule; Roots, Sampling and Logging are deprecated rather than removed, and the lifecycle policy guarantees at least twelve months before anything deprecated can go. Application state itself survives the change. Instead of relying on the transport session, a tool returns an explicit handle and the client sends it back with later requests.

What to check, by role

If you run MCP servers, plan the migration of stateful implementations with the twelve-month window in the schedule, and start any new server stateless with explicit handles. The cost difference compounds.

If you own a platform or gateway, price what header routing and cache rules make possible with equipment you already run. Metering, rate-limiting and auditing MCP traffic moved from custom work to near-standard functionality, and that changes the build-versus-buy line.

If you assess adoption for an enterprise, the lifecycle policy is decision material. A written stability guarantee changes the risk arithmetic of committing to the standard.

:person_raising_hand: Lenses for the next story

First, a revision’s beneficiary list tells you the standard’s direction. Pair each new feature with who it pays, builders or the operators and intermediaries above them, and you can read which stage the standard is passing through.

Second, ownership sets the direction a standard gets shaped in. Peculiarity is an asset to a company and a cost to a foundation, so watch what the first post-transfer revision removes. That is the test of what a donation actually meant.

Third, launch-day reactions locate the demand. When the parties publishing support within hours are gateways and cloud providers, you know who had been waiting for the ground to flatten, and where the next commercial layer forms.

References