The Factory Upgrades Its Own Foundation: An MCP Spec Marathon
Published revised 7 min read
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/discoverrequired, 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-lessserver/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
initializehandler now consults the supported-versions list instead of answering with a hardcoded 2024 version. - Structured tool results. The SDK gained
structuredContentandoutputSchema, 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 itsfileslist, 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/discoveranswers without aninitialize, 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/ssetraffic 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
- 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.
- 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.
- 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.
- Make the agent look for evidence against the plan. The
/sseslice's required search found 22 live consumers my analysis had missed. Stopping cost a plan revision; pushing on would have broken a gateway. - 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.
Related posts
9 min read
The Factory Files a Ticket Against Itself: Two Repos, One Session, Three Gaps
I put fi-fhir and edilint through Mills for the first time. It merged work I did not write, then exposed a test gate passing on the wrong tree and fixed it against itself.
Shared tags: ai-agents · mills · loom
16 min read
A Green Run That Checks Nothing: Seven Silence Modes, Seventy Repos, One Day
A fleet-wide maintenance day exposed seven ways CI can report success without useful work—and the merge-queue discipline and recurring checks built to catch them.
Shared tags: loom · mills
4 min read
The Agent Gets Read-Only Credentials: A Trust Ladder for AI in Regulated Systems
A design pattern for supervised AI investigations: scoped read access, reviewed drafts, and failure tests before expanding permissions.
Shared tags: ai-agents · mcp
Comments
Join the discussion. Be respectful.