One year on: my MCP take, recalibrated

A year ago this month I was writing my first MCP integration and trying to figure out whether the protocol would matter. By the end of 2025 it was clear it did. By February 2026 it's the default. OpenAI's Apps SDK runs on it. GitHub's Agent HQ supports it. Every lab that ships agent tooling supports it. The thing Anthropic introduced in November 2024 became the integration layer for the industry within fifteen months.

That's a faster adoption curve than I predicted. It's also a different shape than I predicted. Some of my earlier takes held up well. Some I'd write differently today. A few things genuinely surprised me. Worth grading honestly while the calls are still fresh enough to remember what I was thinking when I made them.

The takes that held up

MCP would become the integration layer. I called this in March 2025 when most people still thought it was a Claude-specific oddity. By April every major vendor had shipped one and the writing was on the wall. The bet that MCP would beat the alternatives, function-calling-as-a-standard, vendor-specific plugin formats, the LangChain tools abstraction, looks correct now. The protocol won because it was the simplest thing that worked, and because Anthropic shipped it without trying to keep it Claude-only. The open-by-default call turned out to be the load-bearing one.

Routing layers would emerge as a category. I wrote about MetaMCP in September when it was one of a handful of projects in the space. By early 2026 the routing-layer category is settled, there are three or four credible options, the patterns have stabilized, and any team running more than five MCP servers is using one. The bet that the proliferation of MCP servers would force a routing tier between agent and servers played out exactly as I sketched it.

MCP-only agent architectures would work. The October piece on building agents where every tool is an MCP tool was a bet that the architecture would simplify rather than complicate things. Held up. The teams I know who went MCP-only on their tool layer report less framework churn, easier vendor swaps, and real gains on the testability story. The thing I was worried about (the protocol being too constraining for the actually-complex tool calls) turned out not to bite. The constraints were the right ones.

The use cases would consolidate. The late-December piece on the use cases worth tracking (code search, doc retrieval, infra introspection, data-warehouse query) was the right shortlist. These are the four MCP server categories that became table-stakes through Q1 2026. The longer tail I gestured at (CRM, ticketing, observability) is filling in slowly; the core four are everywhere.

These four calls held up. Worth being honest that not every call did.

The takes I'd write differently

I underestimated the labs' willingness to adopt MCP. I assumed OpenAI and Google would build proprietary alternatives and pretend MCP didn't exist for at least another year. They didn't. OpenAI shipped Apps SDK on top of MCP in late 2025, a move I genuinely didn't expect. Google's Gemini tooling now speaks MCP natively. The "every lab does its own thing" call underestimated how much the developer community had already standardized on MCP, and how much pressure that put on the labs to meet developers where they were. The protocol won across labs faster than the protocol-war framing suggested it would.

I overestimated the friction on enterprise adoption. A year ago I thought the corporate-IT story would be the bottleneck, security review, governance, compliance signoff for arbitrary tool integration. It is real friction; it's smaller than I predicted. The MCP server pattern turned out to be easier to govern than the alternatives because the surface area is small and the call patterns are auditable. Enterprises I expected to be on year-two pilots in early 2026 are in production. The governance story matured faster than the protocol war did, partly because the routing layers absorbed most of the audit-and-policy work.

I underestimated GitHub's role. I treated GitHub as one MCP consumer among many. Agent HQ (the GitHub-as-the-control-plane-for-coding-agents play) turned out to be a much bigger deal than I sketched. The fact that GitHub became the default place to wire MCP servers into your dev workflow shifted the developer-adoption curve materially. If you'd told me in February 2025 that GitHub would be the consumer-facing front door for MCP a year later. I would have nodded politely. It happened.

I was too cautious on the routing-layer timeline. I wrote in September that routing layers would mature through 2026. They matured through Q4 2025. The category settled six months earlier than I expected because the proliferation of servers happened faster than I expected, which forced the routing problem earlier. The pattern was right; the calendar was off by two quarters.

These are real misses. None of them invalidate the core take. All of them are worth being plain about because the temptation to remember the takes that worked and forget the ones that didn't is real, and the practice of grading honestly is the only thing that keeps the calls calibrated.

The things that surprised me

A few developments I didn't see coming at all:

The MCP server became a unit of distribution. A year ago I thought of MCP servers as plumbing, the thing you wired up between your agent and your tools. By early 2026 the MCP server is a thing you publish, version, distribute, and depend on. There are MCP server registries. There are MCP server marketplaces. There are companies whose product is an MCP server. The protocol became a packaging format, not just an integration format. I didn't predict that and I should have.

The protocol stayed simple. A year of every major vendor adopting it should, by every prior pattern, have produced a baroque spec full of vendor-specific extensions and incompatible interpretations. It mostly didn't. The MCP spec in February 2026 is recognizably the spec from November 2024, refined, expanded carefully, but not bloated. Anthropic's stewardship has been notably restrained, and the community has pushed back on extensions that would have fractured the protocol. The "open standards always get bloated" pattern didn't happen here. Worth crediting the people who held the line.

Local MCP servers became normal. I assumed MCP would be a hosted-services pattern, your agent talks to remote MCP servers run by vendors. The local-MCP-server pattern, small servers running on your machine that wrap your local files, your local tools, your local context, became at least as important as the hosted pattern. This dovetailed with the personal-AI category in ways I didn't anticipate when I wrote about either. The local MCP server is the foundation piece that makes principled-personal-AI tooling actually composable.

The agent-framework conversation got quieter. A year ago the framework wars were loud. LangChain, LangGraph, AutoGen, CrewAI, Strands, all jockeying. With MCP standardizing the tool layer, the framework you pick matters less than it used to. The framework wars didn't end; they got smaller. The differentiation moved from "what tools can my framework call" to "what does my framework do with the tool calls", which is a healthier place for the differentiation to live. The framework-wars piece I wrote in May was already nodding at this; the trend went further than I sketched.

These are the real surprises. The category looks different from what I expected because of them.

What this changes about the next year

A few takes that fall out of the recalibration:

MCP is now infrastructure. The protocol's role for the next year is the role TCP plays for the internet, present, assumed, not the thing you talk about. The interesting work moves up the stack. The interesting essays will be about what you build on top of MCP, not about MCP itself. I'll write fewer MCP posts in 2026 than I did in 2025, and the ones I do write will be about specific patterns rather than the protocol.

The routing layer becomes the interesting tier. As the protocol stabilizes, the routing layer is where the design decisions move. Caching, policy, observability, fan-out, fan-in, these are the problems the next year of MCP-related work solves. I'd bet the next big MCP-adjacent company is a routing-layer company, not a server company.

Local-first MCP gets a real product story. The local-MCP pattern that emerged organically through 2025 needs a packaging-and-distribution layer. The opportunity is to make local MCP servers as easy to install, run, and maintain as a Mac app. Whoever ships that gets the principled-user category in a way no current player does.

The protocol-war framing dies entirely. Anyone still writing "will MCP win" essays in 2026 is a year late. The framing that replaces it is "what does the post-MCP-standardization stack look like", which is the conversation worth being in.

The MCP-and-personal-AI intersection gets more interesting. The local-MCP pattern plus the personal-AI foundation plus the open-weights tooling are converging into something that doesn't yet have a name. Worth watching closely. Worth being early to the next vocabulary for it.

The honest summary

A year ago I made a set of calls about MCP. Most held up. Some didn't. The biggest miss was underestimating how fast and how completely the labs would converge on the protocol. The biggest correct call was the bet that MCP would be the integration layer rather than one of several. The biggest surprise was the MCP server becoming a unit of distribution rather than just a unit of plumbing.

The protocol won. The protocol stayed simple. The tools grew faster than I expected and in a different shape than I sketched. The work for the next year is on top of MCP, not about MCP. The interesting essays move up the stack.

The thing I want to be honest about, because it's the thing the grading exercise exists for: I was right that this would be a category. I was less right about the specific shape and the specific timeline. The pattern of being directionally right and specifically wrong is the pattern most predictions land in, and the practice of saying so out loud is the only way the next round of predictions gets calibrated.

A year on. MCP is the layer I bet it would be. The ways it isn't quite what I sketched are worth being plain about. The ways it is are worth not pretending I knew all along, some of it I didn't, and that's the honest read.

Worth coming back to in February 2027 to grade the recalibration itself. The compounding-honesty practice is the only thing that keeps any of this useful.