Blog #0198: From Protocols to Platforms and Back

Source: Photo by Muriel Liu on Unsplash

[ED: SMTP is over forty years old, still wide open, and still effectively owned by a handful of platforms. This is a story about the protocol-to-platform loop every technology runs — and why cheap software might be about to run it backwards. 2/5 hats.]

SMTP, the protocol that carries every email you have ever sent, is older than the web and still completely open. Anyone can run a mail server. But if you have tried to run your own mail server recently, you know that "open" and "viable" are not the same word. In practice, email is owned by a handful of platforms. The protocol stayed free. The value did not.

Email is just the example closest to hand. The same pattern runs through almost every important technology I have watched mature. There is a shape to it: genesis, then a protocol era, then a platform era, and then a reset that starts the loop again. Once you have seen the shape a few times, you start to see it everywhere — and, more usefully, you start to be able to guess what comes next.

I think the loop is about to turn, and not for a glamorous reason.

The Protocol Era

It starts when some new capability emerges. Sometimes it comes off the back of the last cycle, sometimes from nowhere obvious. For a while it lives in labs, research groups, and the open-source community, where people poke at it to see what it can do.

Then the protocols arrive. Open standards crystallise around the new capability, and the decisive feature is what they lack: there is no lock-in yet. That absence is the engine. Because nobody owns the protocol, everybody builds on it. Open source flourishes. Free applications multiply. The protocol matures, gets revised, forks, or quietly withers — and as it proves itself, investment arrives, because suddenly there is a surface broad enough to build a business on.

HTTP and HTML. SMTP and IMAP. RSS. TCP/IP. The protocol era feels like abundance, and it feels permanent, but it is neither.

The Platform Era

Once a protocol has proven itself, commercial interests arrive to enclose it. They have no reason to kill the protocol; an open standard with a wall around it serves them perfectly well. They build moats around it: a better experience, a network of users already inside, a default that ships switched on. Then they gate access and the protocol becomes plumbing and the platform becomes the product.

Then comes consolidation, and two moves you can set your watch by. The incumbents who won the last platform era bolt the new protocol onto their existing platform — Microsoft does this in its sleep. And a crop of protocol-native challengers, built clean with no legacy to carry, race them for the same customers.

Email is one of the cleanest cases. SMTP never closed, but spam filtering, storage, and deliverability reputation made Gmail the place email actually happens, and deliverability reputation is a moat a newcomer cannot just decide to have. The open web went the same way through the app stores; RSS went the same way via the algorithmic feed. The protocol is still there in each case, still technically open — and practically irrelevant as a place to compete. The value moved up the stack and behind a wall.

Why the Cycle Turns

I wrote about a version of this years ago, at BCG Digital Ventures, in a piece called "The Right Time for Deep Tech". The framing there was that technology matures through four phases: raw technology, then infrastructure, then marketplaces and operating models, and finally aggregation and disaggregation on top of the stack.

The protocol-to-platform story is that same curve seen from the side. The protocol era is where the raw technology and the infrastructure get built — in the open, because that is the only way they can get built. No single company can fund an entire substrate. The platform era is the marketplace-and-aggregation phase, and aggregation is where the moat forms. The aggregation layer is the part worth owning, so that is where the wall goes up.

The other half of that old piece was about lubricants and frictions — the forces that accelerate a technology or hold it back. Technologies move when something that was in the way is removed, not on any fixed schedule. As Horace Dediu put it: "Those who predict the future we call futurists. Those who know when the future will happen we call billionaires." The cycle turns when a friction disappears.

What's Different This Time

Something has always made the platform era stick.

I think it is the cost of software, specifically the cost of migration. Although you may move to a platform becuase it is wonderful, you rarely stay for that alone. You stay because leaving means rebuilding, and rebuilding is expensive and slow. Switching costs are, mostly, software costs. That asymmetry, cheap to stay and expensive to leave, is the moat. And that is certainly true for traditional SaaS businesses.

Agentic coding reprices this. When building bespoke software gets dramatically cheaper, the asymmetry can flip. It can become cheaper to build a small, purpose-built thing that speaks the open protocol than to migrate or wrap the legacy capability you are trying to escape. In my old vocabulary, that is a lubricant — and a big one. Cheap software is a friction removal large enough to trigger a new protocol era: the substrate re-opens, because the thing that kept everyone penned inside the platforms just got repriced.

You can already see it starting to happen. The AI labs are themselves shipping open protocols (the Model Context Protocol is the obvious one), which is textbook protocol-era behaviour. The platform enclosure will come; it always does. The open questions are when, and what is left to enclose.

Where Is the Value?

If software is cheap and protocols are open, the question moves to what remains (or becomes) defensible.

The moats that survive are the ones that were never really about software in the first place: proprietary data, distribution and default placement, regulatory position, genuine network effects, anything anchored in the physical world. None of those get cheaper just because code does.

But some "moats" were only ever software-cost moats wearing a costume, and those moats are draining. The uncomfortable question writes itself: If a moat depended on software being expensive, and software is no longer expensive, was it ever really a moat?

And if a whole category of moats drains at once, what happens to competition? I think you get one of two things, possibly both at once in different layers of the stack. Either margins compress toward the cost of the underlying compute and competition turns brutal and thin — or the scramble moves to the moats that don't depend on expensive software, and those become more valuable and more contested than ever. I don't think anyone knows yet and that is the genuinely interesting part.

And Back

The title of this piece is "from protocols to platforms and back." The "and back" is the bet.

I am not predicting that platforms die. They are durable, and the incumbents are not stupid. My claim is narrower, and I think more useful: the thing that made platform enclosure durable, expensive software and expensive migration, is being repriced in front of us, and a repricing like that is exactly the kind of friction removal that turns the cycle. We may be closer to the start of a protocol era than the end of one.

If you are building, that should change where you look. Don't dig the moat that assumes software stays expensive — it may be dry by the time you finish it.

The rest is timing. The futurists will tell you that the cycle turns. Knowing when was always the main game.

Regards,
M@

Originally posted on matthewsinclair.com and cross-posted on Medium.

[ED: If you'd like to sign up for this content as an email, click here to join the mailing list.]