TCP/IP took nine years to deploy. MCP moved to the Linux Foundation in one. That contrast explains everything about how protocol development has changed.

The old way

In May 1974, Vint Cerf and Bob Kahn published A Protocol for Packet Network Intercommunication. It described how to connect different computer networks. Good idea. Important work.

Then they waited. They refined. The Department of Defense adopted it in 1982. But the real “Flag Day” (when ARPANET officially switched to TCP/IP) didn’t happen until January 1, 1983.

Nine years. From paper to adoption.

That wasn’t slow by the standards of the time. That was normal.

HTTP/2 took three years from proposal to RFC 7540 in 2015. TLS 1.3 took four years of debate before RFC 8446 dropped in 2018. IPv6 was standardized in 1998 (RFC 2460) and I’m pretty sure my toaster still doesn’t support it.

David Clark said it best in 1992: “We reject kings, presidents and voting. We believe in rough consensus and running code.”

Rough consensus took time. The people building those foundations assumed their work would outlast them, so they were careful. They documented everything. They thought about what might break in fifty years.

The new way

Anthropic announced the Model Context Protocol (MCP) on November 25, 2024.

By December, there was an SDK. By January 2025, Claude Desktop shipped with native support and over a hundred community integrations existed.

And then, on December 9, 2025, just over a year later, Anthropic donated the whole thing to the Linux Foundation’s new Agentic AI Foundation.

The explosion of newcomers

It’s not just MCP. 2025 gave us a “Cambrian explosion” of ways for agents to talk to each other.

Agent2Agent (A2A) from Google dropped in April 2025. It’s focused on cross-platform coordination. Over 50 partners—including Salesforce and SAP—signed up at launch. Again: months, not years.

Agent Protocol went the community route—a tech-agnostic REST spec for any agent frame.

Agent Client Protocol (ACP) came out of Zed and JetBrains, standardizing how coding agents (like Claude Code) talk to editors.

Universal Tool Calling Protocol (UTCP) emerged as an alternative to MCP for simpler execution needs.

Universal Commerce Protocol (UCP) dropped in Jan 2026 (Google again), specifically to standardize how agents buy things.

Agent Payments Protocol (AP2) emerged in Sept 2025 with 60+ partners (PayPal, Coinbase) to handle the money side—ensuring agents can actually pay for what they find.

We went from having zero standard ways for agents to communicate to having almost a dozen competing “standards” in eighteen months.

Not everything is moving fast

You might be thinking: “Wait, real standards still take time.”

You’d be right.

OAuth 2.1 has been a draft since 2020. Five years later, it’s still being refined. That’s good. We don’t want login security changing every Tuesday.

I’ve been part of TC39 (the committee that standardizes JavaScript). We have a rigorous stage process. We debate edge cases for months or years. It works—JavaScript runs everywhere on earth. But it’s not “ship it next week.”

ActivityPub took three years to standardize (2015-2018) and another eight to really hit the mainstream.

The “ship in weeks” phenomenon is specific to this AI moment. It’s what happens when protocols are built by startups instead of consortiums.

Compare that timeline:

• TCP/IP: 9 years from paper to deployment.
• MCP: 1 year from announcement to open governance.

No IETF working group. No decade of debate. They shipped the SDK, verified it worked in production, and then handed it off.

I’ve built MCP servers. The developer experience is good. You can go from zero to working integration in an afternoon. That’s real progress.

What’s different

The old process had:

• Academics and engineers from different organizations
• IETF, W3C, IEEE standards bodies
• Years of review and testing
• Formal documentation that will exist forever
• No single entity in control (from the start)

The new process has:

• Company ships SDK
• Developers build on it
• Company iterates based on usage
• Then it moves to a foundation (if we’re lucky)
• README.md is the documentation

What still worries me

TCP/IP was designed to route around nuclear war. The people who built it cared about resilience, about infrastructure that would outlast any single company or organization.

The recent move to the Linux Foundation is a great sign for MCP. It calms my biggest fear—that it would just be an Anthropic product forever.

But the mindset is still different. We’re building protocols like products. We iterate on them like apps. Breaking changes are just a version number away.

RFCs are immutable. RFC 791 will always be RFC 791. GitHub repos are living codebases. If the company pivots or the repo is deleted, the “spec” effectively vanishes. In five years, will we be able to look up why a decision was made, or will those issues be long gone?

I feel this myself. I built OKAP because I wanted an open protocol for knowledge access that wasn’t tied to any single vendor’s ecosystem. It’s my attempt to build something durable in a fast-moving world.

The adoption cheat code

Why is adoption so fast now? It’s not global consensus. It’s usually one of two things: proven utility or room consensus.

MCP was the first type. Anthropic didn’t form a committee. They just shipped it. It worked. By March 2025—just four months later—OpenAI, Microsoft, and Google had all integrated it. The ecosystem rallied around it because it solved a pain point, not because a board voted on it.

Other times, like with Google’s UCP, it is room consensus. It launched in Jan 2026 not as a proposal, but with 20+ partners like Shopify, Walmart, and Stripe already signed on.

Technically, these are open protocols. Anyone can implement them. But let’s be real: giants control the clients, the servers, and the distribution. Their “open” standard has a billion users on day one. Yours has a GitHub star.

There’s a dark side to this.

In the RFC era, the process was excruciatingly slow, but it was democratically open. If you had a good idea and the patience of a saint, you could shift the internet.

Today? If you’re an individual with a brilliant idea for a protocol, good luck. Without a corporate manufacturing partner, your “standard” is just a Repo. The noise floor is too high. Unless you can get adoption from the giants, you’re shouting into the void.

The question

Every time we build something, we’re making a bet about how long it needs to last.

The TCP/IP people bet on decades. They were right.

The people building AI protocols are moving at the speed of AI. That means weeks, maybe months.

Shipping fast allows for incredible innovation. We wouldn’t have the agentic ecosystem we have today if we’d waited for an IETF committee to define “tool use.”

But as we build these layers, we should ask: are we building scaffolding, or are we pouring concrete?

Because if this acts like concrete, I really hope we got the mix right.