Skip to main content
Back to Writing

The Factory Upgrades Its Own Foundation: An MCP Spec Marathon

Published revised 7 min read

Labmcpai-agentsloommillsautomationplatform
The Factory Upgrades Its Own Foundation: An MCP Spec Marathon — hero illustration

On July 28, 2026, the Model Context Protocol release introduced breaking changes: stateless core, a new server-initiated-request model, an extensions framework, and a 12-month deprecation clock on a pile of features. My whole platform speaks MCP. The hub, the ~30 production servers, the agent factory that ships code to them — all of it runs on an in-house Go SDK, about 8.5k lines, that I maintain myself. And it was two spec revisions behind.

I kept the compatibility analysis and migration decisions under my review, then gave Mills bounded implementation work, including changes to the SDK its own tools depend on.

TL;DR

  • The 2026-07-28 MCP revision is breaking on purpose: handshake removed, server/discover required, MRTR replaces held-open streams, HTTP+SSE and DCR start their deprecation clocks.
  • I wrote a source-backed gap analysis with a file:line inventory of my own protocol surface, a phased roadmap, and a monthly kill-test for the riskiest assumption.
  • Then I filed the roadmap not as tickets for me, but as backlog for Mills, the autonomous factory that runs on this SDK. Its first task was making the SDK's own repo workable by the factory.
  • On August 26, Mills merged the SDK half of the migration: version negotiation, structuredContent, handshake-less server/discover, and removal of the legacy SSE transport. Six of the campaign's eight slices merged autonomously, one merged after my review by design, and one stopped because its premise was false.
  • Clients have preferred structured JSON since August 26, which routes around a real data-loss bug in the SDK's text encoding. The encoder itself became lossless on October 26.
  • The hub's transport decision is still open on purpose, until a one-server spike gives me evidence.

The reading is human work

I started with the release, changelog, and specification proposals, then mapped each change to a file and line in my implementation. That inventory separated protocol incompatibilities from features the platform had never adopted.

Two findings set the plan's shape. First, the deprecation list landed almost entirely on features I never adopted — sampling, roots, MCP logging, SSE resumability. Tools-only was the right bet years ago, and the spec just agreed. Second, the genuinely scary items weren't features but contracts: the handshake goes away, every result grows a required resultType, and my leaf servers were answering initialize with a hardcoded version from 2024 while the proxy negotiated something newer — a split-brain that worked only because nothing was checking.

The analysis ends the way I now end every plan: with the riskiest assumption stated out loud, and a kill-test for it. My assumption is that vendor CLIs keep their legacy-handshake fallback long enough for a phased migration. The monthly test is concrete — newest vendor builds, stdio proxy, tools/list plus one tools/call round-trip — and the first run had a nice property: the research session itself was running through the proxy under test.

The migration is factory work

Mills is my cluster's autonomous delivery system: it takes backlog items, plans them in a council, implements in sandboxed spawns, runs gates (fmt, lint, tests, docs, scope), opens MRs, watches CI, and escalates to me with a dollar figure attached when it's stuck. I've written about the orchestration before; the new thing is what I pointed it at.

The roadmap's item zero was make libs/mcp-go a Mills-workable project. The SDK the factory's own tools are built on wasn't in its spawnable-projects list, so the first slice of the migration was the factory extending its reach into the repo that defines it. There's a strange-loop quality to that, but it's really dependency ordering: the factory can't change a repo it can't clone, build, and test.

The enablement change escalated on scope, and I finished it by hand. The smoke test after it took five attempts, each stopped by a different real gap: a clone that failed because the rollout was still on the old image, a path policy that failed closed on a repo it had never seen, a tests stage that cloned the wrong repository path, and a diff check that reported an empty change. The fifth attempt ran the whole lane and merged a README change early on August 26 (UTC).

The SDK work followed within hours. Each of these merged on August 26:

  • Version negotiation. The SDK's initialize handler now consults the supported-versions list instead of answering with a hardcoded 2024 version.
  • Structured tool results. The SDK gained structuredContent and outputSchema, and the hub, bridge, and Mills clients in loom-core now prefer structured JSON when a tool provides it. That matters because the SDK's default output format is a compact text encoding whose tabular form silently dropped array-valued columns, the documented root cause of three separate incidents (a plan reader losing its files list, zeroed test verdicts, a blanked cluster HUD). Clients that read structured results stopped depending on that encoding. The encoder itself stayed lossy; see the update below.
  • Handshake-less discovery. server/discover answers without an initialize, and tool lists come back in a deterministic order with cache hints.
  • Legacy SSE removed from the SDK. The HTTP+SSE transport is deprecated upstream, and nothing built on the SDK used it.
  • Auth modernization. The spec deprecates Dynamic Client Registration in favor of Client ID Metadata Documents, on a 12-month clock. A factory lane implemented the CIMD path alongside DCR. Because it touches OAuth, the item carried a security label that holds its merge request for my review, and it merged after that review with DCR kept for the deprecation window.

One slice refused to run. Removing loom's own /sse endpoint was planned as cleanup, because my analysis said nothing used it. The implement agent's required search for evidence against the plan found 22 live /sse endpoints in the configuration of mcpo, the OpenAPI gateway in front of the fleet, so it pushed no diff and escalated. My analysis had been right about the SDK and wrong about the platform. A research lane then wrote the migration plan for those consumers.

loom-core's merge history shows the scale around this. Of the last 111 merges to its main branch before I published, going back to August 16, 69 came from factory lanes. I reviewed escalations and made the judgment calls.

Decisions still open

Two strategic questions are parked in the roadmap: whether the hub fabric moves from WebSocket sidecars to the spec's stateless streamable HTTP, and whether the leaf servers eventually adopt the official Tier 1 Go SDK instead of my in-house one. I'll decide both on evidence, and the plan calls for a one-server spike before choosing. The stateless transport was practically designed for my fleet's shape, which is exactly why I want the spike before I trust my enthusiasm for it.

The campaign closed on August 26 at the stop-line I had set: the SDK and client work merged, the hub fabric untouched, and Phases 2 and 3 waiting for a fresh plan.

Update, October 2026

I rechecked this post against the repositories on October 30 and corrected several claims in place. The three that mattered most: the first version said the SDK half was staged and would land next; it had merged on August 26, three days before I published. It presented a docs-guardrail gate as something the factory built during the marathon; I built that gate on July 17, eleven days before the spec release. And it said the structured-content work retired the encoder's data-loss bug; it only moved clients off the lossy path.

What happened after publication:

  • mcpo moved off /sse. On August 29, Mills merged eight merge requests that moved mcpo's consumers to Streamable HTTP. A soak from August 29 to 31 found no /sse traffic on the hub, and I removed loom's legacy HTTP+SSE transport on September 12.
  • The encoder is fixed at the source. The text encoder built a table from the keys every element shared, so arrays of objects with a nested value, an array field, or a key missing from some elements lost those fields. Since October 26 it builds a table only when no field would be dropped and uses its list form otherwise.
  • The transport decision is still open.

Takeaways

  1. Spec reading is judgment work; spec migration is throughput work. Having me interpret the spec and the factory implement the migration has been the most useful division of labor I've found.
  2. File the roadmap as executable backlog. A phased plan whose slices are machine-workable items gets executed. Most of this one merged within a day of filing.
  3. Point the factory at its own foundation early. The enablement slice (can the factory even work in that repo?) is the real item zero. Here its smoke test flushed out four gaps before any SDK work queued behind it.
  4. Make the agent look for evidence against the plan. The /sse slice's required search found 22 live consumers my analysis had missed. Stopping cost a plan revision; pushing on would have broken a gateway.
  5. State the assumption that kills you, and test it monthly. Mine is vendor-client fallback; the day that test fails, the queue reorders itself.

The trust-ladder rules from the companion post hold here too: every factory merge went through gates, CI, and a reviewable merge request. The factory rebuilt part of its own foundation the way I'd ask any engineer to, with recorded checks and reviewable changes.

Comments

Join the discussion. Be respectful.

The Factory Upgrades Its Own Foundation: An MCP Spec Marathon | Cody Blevins