In 1995, you could get online through CompuServe, AOL, or Prodigy. Each was a walled garden. CompuServe had its own email system, its own forums, its own content. AOL had different email, different forums, different content. If you were on CompuServe, you couldn't send email to someone on AOL. They were separate universes that happened to use the same phone lines.
Then the open internet ate them all.
I keep thinking about this history as I watch the AI agent ecosystem take shape, because I see the same pattern repeating. Every major platform is building a closed agent environment. OpenAI has its plugin system and GPT store. Google has its agent frameworks tied to Vertex. Amazon is building Bedrock agent tooling. Microsoft has Copilot Studio. Each is a garden with walls.
I think this is heading somewhere predictable. And I think the companies betting on closed ecosystems are going to lose to the ones betting on open rails.
Why Closed Agent Systems Can't Scale
Here's the practical problem with closed agent ecosystems: agents need to talk to other agents, and they need to use services built by people who didn't necessarily choose the same platform.
Imagine you build a useful MCP server that does, say, contract analysis. You want AI agents to use it. Under a closed model, you'd need to register it with OpenAI, and separately with Google, and separately with Amazon, each with different specs and different approval processes. And an agent on Platform A still couldn't use services on Platform B.
This is exactly the CompuServe/AOL problem. Fragmentation makes every service less valuable because it can only reach a fraction of the potential users.
The web won because a website worked from any browser on any operating system. An agent service needs to work from any AI model on any platform. That requires open protocols, not proprietary ecosystems.
What "Open Rails" Actually Means
When I say agents need open rails, I mean something specific. Not open-source (though that helps). I mean standardized protocols at the infrastructure layer that anyone can implement.
For tool invocation: MCP is a strong start here. Anthropic open-sourced it, and it's gaining adoption across platforms. This is like HTTP was for the web: a shared way for clients and servers to communicate. Good.
For discovery: There's no standard yet. How does an agent find a service? Today, a human configures it. That doesn't scale. We need a way for agents to query registries, compare services by capability, check pricing and trust signals. This is like DNS was for the web. We don't have it yet.
For payments: If agents need to pay for services, how? Traditional billing (API keys, monthly invoices) requires human setup for every new service. x402 is one approach: pay-per-call using stablecoins, with the payment protocol built into the HTTP layer so any agent can use any paid service without pre-registration. There might be other approaches that work. The point is we need a standard, not a dozen proprietary billing systems.
For identity and trust: How does an agent know a service is legitimate? We need verifiable identity for agent services. Something like TLS certificates for the agent world, where you can check that a service is who it claims to be and has a track record of reliability.
The Incentive Problem
I'm not naive about why platforms build walled gardens. There's an obvious business incentive. If all agent services live inside your ecosystem, you control the distribution, you take a cut, you own the customer relationship. This is the app store model, and it's been incredibly profitable for Apple and Google.
But the app store model works because phones are personal devices with tight hardware-software integration. The agent economy doesn't have that constraint. An AI agent doesn't care what platform it's running on. It just needs to reach the right service. The switching costs that make app stores sticky don't apply when the "app" is an API endpoint that any agent can call.
I think the platforms that try to build closed agent ecosystems will find that the best services route around them. If a developer can reach more agents through an open registry than through any single platform's store, they'll go open. And if agents can find better services through open discovery than through a platform's curated list, they'll go open too.
The gravity is toward openness. It just takes time for everyone to realize it.
Lessons from Protocol History
The internet's protocol stack wasn't designed by a committee and handed down from on high. It grew layer by layer, each layer solving a specific problem that the layers below didn't address.
IP gave us addressing and routing. TCP gave us reliable delivery. DNS gave us naming. HTTP gave us document transfer. TLS gave us encryption. Each protocol succeeded because it was open, simple enough to implement, and solved a real problem that developers were already working around in ad-hoc ways.
The agent stack is following the same pattern, whether anyone planned it or not. MCP is the TCP equivalent: reliable tool invocation. Now we need DNS (discovery), we need the equivalent of HTTP (standard service description and interaction patterns), and we need TLS (identity and trust).
Every time I look at a team building a proprietary version of one of these layers, I think: you're building a better CompuServe. Good luck with that when the open internet shows up.
What I'd Like to See Happen
I don't have a grand plan for the agent protocol stack. I'm suspicious of grand plans. But I have some opinions about what would help.
First, more companies should adopt MCP and contribute to its development. It's good but it needs work on security, payment hooks, and service description. The more implementations there are, the faster the rough edges get filed down.
Second, someone needs to build a federated discovery protocol. Not a single registry that becomes a gatekeeper, but a protocol that lets any registry interoperate with any other. SocioLogic is building a registry, and we're trying to design it so it can federate with others. I don't know if we'll get the design right, but I know the right answer isn't a single centralized directory.
Third, payment protocols for agents need to mature. x402 is our bet, but the broader point is that per-call payments using open protocols should replace per-month billing through proprietary systems. The economics of agent work require it.
Fourth, the AI labs should resist the temptation to make their agent ecosystems proprietary. I understand the business logic. But I also remember what happened to every company that tried to build a proprietary internet in the 90s.
The agent economy will be bigger than any single company can capture. The winners will be the ones who build on open rails, not the ones who try to own the rails. I'd bet real money on that. In fact, I already am.