Why I Believe in Open Systems
On participation, interoperability, and what outlasts a platform
Every closed platform makes the same promise: we will handle the complexity for you. It is a real promise, and for a while it is usually true.
So the question is not whether closed systems work. They work well — often better than open ones at the start, with cleaner interfaces and faster decisions. The question is what happens over a decade.
Two ways to compound
A closed system compounds internally. Every improvement accrues to the entity that owns it. That focus is genuinely an advantage: one roadmap, one architecture, no negotiation.
An open system compounds across everyone who touches it. Improvements accrue to participants the owner never met and never planned for. Progress arrives from directions no roadmap anticipated.
Early on, the closed system looks obviously better. It is coherent while the open one is still arguing about specifications. The advantage inverts slowly, then structurally — because the open system is accumulating contributors while the closed one is accumulating dependencies on a single decision-maker.
A platform optimizes for capture. A protocol optimizes for participation.
What open actually means
Open does not mean free, and it does not mean unmanaged. The word gets stretched until it stops carrying information.
The properties that matter are narrower:
| Property | What it means |
|---|---|
| Permissionless participation | You can build without asking — no business development conversation decides whether you are allowed to exist. |
| Interoperability | Components can be replaced. Nothing is load-bearing purely because it is hard to remove. |
| Shared knowledge | The design is inspectable. Understanding does not require a relationship. |
| Credible constraints | The rules are hard to change unilaterally, so building on them is a defensible decision. |
That last one does most of the work. Openness is not a license file. It is a commitment about who is allowed to change the rules and how.
Why open ecosystems outlast closed platforms
Closed platforms do not usually fail because the technology was wrong. They fail because the incentives drift.
A platform that needs to capture more value eventually competes with the people building on it. Terms change. Access narrows. The API that was a foundation becomes a liability. Every developer who has been deprecated out of a business has learned this in the same expensive way.
Open systems fail differently — slowly, through fragmentation and coordination cost, not through a unilateral decision made in a meeting no participant attended. That is a meaningful difference if you are the one building on top.
The asymmetry is not moral. It is structural. Closed systems concentrate the risk of a single actor's incentives changing. Open systems distribute it.
The honest tradeoff
Open systems are slower to coordinate. Governance is harder than a decision. Early experience is usually worse, because nobody owns the whole path. Standards take years, and some of them are bad.
If your only horizon is the next two quarters, a closed platform is frequently the correct call, and pretending otherwise is not judgment — it is ideology.
The case for open is not that it wins every round. It is that the cost of being wrong is recoverable. When a closed platform changes its terms, you rebuild. When an open system disappoints you, you fork it, replace the component, or route around it. One of those is a migration. The other is an afternoon.
This is why I treat openness as a decision about reversibility rather than a preference about culture. The most expensive technical decisions are the ones that are hard to undo, and depending on a system whose rules someone else can rewrite is exactly that kind of decision.
In practice
Openness is not binary, and treating it that way leads to bad architecture in both directions. The useful question is not is this open? but what happens to me if the owner's incentives change?
Use closed systems where the switching cost stays low and the leverage is real. Prefer open ones at the layers you cannot afford to migrate — data, identity, settlement, anything that becomes load-bearing. Keep the boundary explicit, so the dependency stays a choice rather than something you discover during an incident.
The goal is not ideological purity. It is keeping your options open long enough to learn which ones you needed.
Innovation compounds when participation is open. Not because open systems are virtuous, but because more people are allowed to try.