The most successful developer technologies of the last 20 years share one thing in common. It's not what you think.

I recently attended the MCP Dev Summit in New York. The room was full of engineers doing serious work on the infrastructure that will define how AI agents connect to the world. The energy was real. The technical quality was high.

I was also, in many rooms, the oldest person there.

That matters. Not because age confers wisdom automatically — it doesn't. But because some of the most important lessons in technology are not in any textbook. They're in the lived experience of watching a standard win, watching a walled garden fail, and understanding the difference between open source and open governance.

What I watched today concerns me. And I think it should concern anyone building on MCP.

The Shift That Changed Everything: Open Source Was Not Enough

In the early 2000s, enterprise software had a problem. The dominant tools — proprietary databases, closed middleware platforms, vendor-locked frameworks — were expensive, inflexible, and controlled by companies whose interests did not always align with the developers building on them.

The shift to open source broke that model. Linux displaced proprietary Unix. MySQL and PostgreSQL challenged Oracle's dominance. Apache became the web server of the internet. Developers who had been locked into vendor stacks suddenly had alternatives that were free, inspectable, and improvable.

But here's what the last 20 years actually taught us: open source alone is not the answer. Open governance is.

Look at the languages that have become the foundation of modern development. Python is governed by the Python Software Foundation — an independent nonprofit. Rust, after Mozilla's 2020 layoffs threatened its future, was saved by the formation of the Rust Foundation, an independent nonprofit that now stewards the language with community governance. JavaScript's core specification is governed by TC39, a committee under Ecma International — a neutral standards body with no commercial stake in the outcome.

These languages did not win because they were technically superior to every alternative. They won because developers could trust that no single company controlled their future. The governance structure was as important as the code.

The counterexample is instructive: Go is an excellent language, widely used, genuinely open source. It is also controlled by Google. That single fact creates a ceiling on its adoption in contexts where developers and enterprises are uncomfortable building critical infrastructure on a foundation one company can redirect.

Open source gets you the code. Open governance gets you the trust.

A Lesson From Before Most Developers Were Building: AOL Keywords

For developers who entered the industry in the last 15 years, here is a piece of history worth understanding.

In the mid-1990s, America Online (AOL) controlled the on-ramp to the internet for tens of millions of people. At its peak, AOL had 30 million subscribers and was, for much of mainstream America, synonymous with "the internet." To have a presence — to be discoverable, to be reachable, to exist where your customers were — businesses registered an AOL Keyword. Type "Nike" into AOL, you got Nike's presence on the platform. Simple, frictionless, and entirely controlled by one company.

That model failed. The open web won.

Not because AOL's technology was bad. Not because the user experience was worse. But because a single company controlling the on-ramp to digital presence is structurally unstable. Eventually, the open web's distributed, neutral infrastructure proved more resilient, more innovative, and more trustworthy than any walled garden.

I am watching a version of this dynamic form around MCP. And the version forming today is more sophisticated — and more dangerous — than AOL.

What MCP Is, and Why It Matters

The Model Context Protocol (MCP) is an open protocol originally developed by Anthropic and donated in December 2025 to the Agentic AI Foundation (AAIF), which operates under the Linux Foundation. MCP defines how AI agents — autonomous systems that can take actions, make decisions, and use tools — connect to external data, applications, and services.

I am a member of the AAIF. I was at this summit. I believe MCP is the right shape of solution for the problem it addresses. The protocol is well-designed, the community is doing genuine work, and the adoption curve is extraordinary.

And I have been here before.

In the past, I worked actively with the Solid project community — the decentralized web initiative founded by Tim Berners-Lee, the inventor of the World Wide Web. My work was applied: facilitating working sessions, hosting events, and translating the protocol's vision into real enterprise use cases. I continue to engage with the Solid working groups today.

What that work taught me, and what Tim Berners-Lee has spent decades demonstrating, is that protocols do not survive on technical merit alone. They survive — or fail — based on who governs them and what those governors are incentivized to do.

The Governance Structure Nobody at the Summit Was Discussing

The AAIF's Platinum governing members are Amazon Web Services, Anthropic, Google, Microsoft, and OpenAI.

Five companies. Each competing with the others on AI models, cloud infrastructure, and enterprise platforms. Each with direct financial interest in which patterns become standard, which authentication schemes get blessed, which registries become authoritative.

The Linux Foundation provides administrative infrastructure. It is funded by those same companies.

The W3C — which governs the web on the principle that no single company should control its direction — is not at this table. Neither is the IETF, which governs the internet protocols the web runs on. Neither is Ecma International, which governs JavaScript.

The institutions that made the web's open standards actually open are absent from the conversation defining the open standards for agentic AI.

What we have instead is a protocol that is open source — the code is freely available, the spec is public — but whose governance is controlled by the companies with the most to gain from directing its evolution.

Remember the Go language lesson: open source is not open governance.

The AOL Pattern, Distributed

Here is the structural risk in precise terms.

In the agentic AI world, AI agents need to discover and invoke tools. A commerce intelligence tool, a CRM tool, a financial data service — each needs to be discoverable by the agents that will use it. The mechanism by which tools are discovered, authenticated, certified, and invoked is being defined right now. By the companies that build the AI clients those agents run inside.

To have a presence as a tool in the agentic AI world, you will increasingly need to be recognized by Claude, ChatGPT, Gemini, and their enterprise variants. The registry standards, conformance requirements, authentication flows, and discovery protocols are being written by the companies that control those clients.

This is not one company requiring an AOL Keyword. It is five companies collectively defining what it means to be a valid, trusted, discoverable tool in the agentic ecosystem.

AOL failed because one company could not sustain a closed on-ramp to an open web. Five companies collectively owning the on-ramp is more resilient, harder to route around, and — because it presents itself as open — much harder to name and resist.

The walls are invisible because they are written in conformance specifications and registry protocols. They look technical. They are political.

This Is Not a Criticism of MCP

I want to be precise here, because this argument is easy to misread.

MCP is a good protocol. The problem it solves — giving AI agents a standardized way to connect to tools and data — is real, important, and not going away. The community building on it is doing serious work. I see that.

The concern is not with the technology. The concern is with the governance structure, and what that structure will produce over time.

The web standards wars of the late 1990s — Netscape versus Microsoft, proprietary HTML extensions, websites that only worked in one browser — were not caused by bad technology. They were caused by companies with financial interests writing standards that reflected those interests. The W3C existed to fight that. It did not fully succeed, but it slowed the fragmentation enough that the open web survived.

The question for MCP is not whether the founding companies intend to keep it open. Intentions are not governance. The question is whether the structure that governs MCP's evolution will produce open outcomes when the interests of the governing companies diverge from the interests of the developers and enterprises building on top of it.

Right now, that question does not have a satisfying answer.

What Should Happen

The web standards community — W3C, IETF, Ecma International — should engage with MCP and agentic AI protocols actively and immediately. The problems being solved at this summit are not new. These institutions have the vocabulary, tooling, and governance track record to handle them. Their absence is not benign; it is a gap that will become costly.

The AAIF should actively pursue involvement from neutral governance bodies — not as a critique of its founding members, but because a standard governed only by its commercial beneficiaries will eventually be treated as a proprietary standard, regardless of whether the code is open source.

And developers and enterprises building on MCP should pay attention to governance, not just technology. The question to ask is not "does this protocol work today" but "who decides what this protocol becomes in five years, and what are they incentivized to do?"

The most successful developer technologies of the last 20 years — Python, Rust, JavaScript, Linux — are not just open source. They are governed by entities with no financial stake in controlling their direction. That is not a coincidence. It is the lesson.

MCP has the architecture to become the HTTP of the agentic era. Whether it does depends not on the quality of the code — which is good — but on whether the people building it are willing to put governance structures in place that would survive even if the founding companies' interests change.

That work needs to start now, while the standard is still forming and the walls are still low enough to see over.

Jon Pederson is Co-founder of Gierd, a marketplace intelligence and commerce operations platform for Fortune 500 enterprise brands. He is a member of the Agentic AI Foundation. He worked actively with the Solid project community — Tim Berners-Lee's decentralized web initiative — facilitating working sessions and applying open web standards to enterprise use cases. He has founded or led more than eight companies across three decades of building on the internet. He is a member of the Forbes Business Council.