The Problem
For software's entire history, the expensive part was making it. Writing, designing, and debugging were paid up front; running the finished product was nearly free, since serving one more user cost almost nothing. The whole industry was designed around that dynamic Subscriptions, licenses and ads exist to recover that large up-front cost by spreading it across many users over time.
AI is breaking this in two ways at once. First, it collapses the cost of creating software. Second, the cost of running it does not fall. Every request still burns compute, storage, and bandwidth. Additionally, software that serves AI models carries a more substantial, variable cost per use.
Both forces break the same hidden assumption that every subscription and ad model quietly depends on: that the marginal cost of one more user is close to zero, so a large fixed cost can be amortized across a crowd. The industry-wide drift away from flat subscriptions toward usage-based, credit, and metered pricing for AI products is evidence of this assumption breaking in real time.
The consequence is a coming flood of useful software — niche utilities, personal tools, and even substantial apps with real users — that costs increasingly less to build but still costs real money to operate. When the maintainer loses interest, moves on, or tires of paying to run something that doesn't directly benefit them, it dies. It is the tragedy of the commons: everyone benefits, a few unpaid people carry the cost, and it runs on goodwill until the goodwill runs out.
The two most common methods of distributing software both carry significant drawbacks. SaaS assumes a company exists to fund hosting and maintenance indefinitely. It works well for software that can support a company, and leaves everything below that line invisible while opening the door to incentives misaligned to the user's best interests. Self-hosted open source is free and forkable, but for a non-technical user, it is effectively inaccessible.
Neither of these options simply lets a useful thing exist because it's useful. That's the gap The Substrate targets.
How It Works
Billing inversion. Today the creator pays to host users and recovers the cost through philanthropy, subscriptions or ads. The Substrate flips this: each user pays for the costs they personally cause — the reader pays for reads, the writer pays for writes. The developer stops carrying the bill and can go genuinely set-and-forget. Because the user pays directly, the user is the customer by construction, not the product. There is no mechanism to excessively extract from or take advantage of any party. Those who create value are naturally rewarded for the value they create. It is quintessentially, the ultimate free market.
One wallet, one identity. A single account and wallet work across every app on the platform. Users top up once and spend across everything, with transparent usage, spend limits and warnings, and visibility into the shape of their own costs and how costs are distributed across an app's users. They also deserve clear transparency into how revenues are utilized to support the app and the platform fairly.
Dependency-tree revenue splitting. Because one platform sits in the execution path of every app — it can split an app's revenue down its entire dependency tree. Every library, module, and fork an app is built on can be paid in proportion to its contribution, automatically, each time the software runs. Existing open-source funding tools already know how to route money down a dependency graph; what they could never solve was getting anyone to pay in. Here the end user pays for usage they were already getting value from, and the money flows down the tree on its own.
Forkable by default. Apps and the platform itself are open and forkable. Forks don't sever the value chain — royalties can keep flowing to the original contributors — so building on someone's work doesn't cut them out. Ownership of an app can also be transferred to a new maintainer, with users and data moving natively, so software can outlive any one person's involvement.
Efficient by design. In order to effectively distribute and attribute resource usage across users fairly, the runtime must be event-driven and scale to zero, so applications are efficient by necessity.
Predictable pricing on top of metering. Raw pay-per-use is mentally taxing, so the platform layers on the classic fixes: the wallet bundles many tiny costs into one top-up, developers can declare flat fees (effectively a subscription) in a manifest, and a free tier covers light users by subsidizing with heavier users or ads. Importantly, ad revenue is only used to support a user's direct costs so that the user remains the primary customer.
What Each Side Gets
- Users: one wallet and identity across all apps; pay only for what you use and nothing when idle; transparent, limitable spend; and the user is always the customer so value naturally aligns with the users best interests.
- Developers: distribution, hosting, and billing handled; ship and walk away with no ongoing infrastructure bill; optional revenue through declared flat fees or royalties; and automatic earnings whenever their contributions are used to create value for someone else.
- Organizations: pay for employees' usage and observe that usage clearly.
A Bigger Implication
Because apps are forkable, ownership is transferable, and the platform — not any single person — runs the code, The Substrate enables open-source, distributed ownership of large-scale, highly concurrent systems. Software no longer needs one human or company permanently responsible for it in order to keep running. If a maintainer disappears, the service can continue without their permission.
The most immediate value of The Substrate is in the explosion of useful software that doesn't justify a company. But the principle underneath it is not just a long-tail property. "The user is the customer" is structural, and the failures of today's largest consumer platforms are all downstream of the advertiser or investor being the real customer instead of the person using the product. In principle, the same inversion that lets a tiny app exist could let society's most central software exist aligned: a social platform geared to its users rather than its advertisers; a dating app whose only incentive is to deliver as much value to the user as possible, because that is who pays it; open-source, forkable, user-funded versions of the software billions of people rely on. That possibility is the long-horizon reason the model matters.
The Hard Parts
- Liability and regulation Because the platform runs everyone's code and directly collects revenues from users, it sits closer to a host than to a passive app store — which leaves genuinely unresolved the question of who answers for an app that turns out to be harmful or illegal. The developer may be anonymous, gone, or judgment-proof, while the platform that executed the code and collected the revenue is the obvious deep pocket.
- Micro-transaction fatigue. People dislike deciding, repeatedly, whether each tiny charge is worth it — and that mental cost doesn't shrink as the price shrinks. The wallet (a bundle), declared flat fees (a subscription), and the free tier (a subsidy) are the three mitigations.
- Fair revenue splitting. "Pay people by contribution" has a precise mathematical form (the Shapley value), but it is exponential to compute and must be approximated — and once real money flows along it, people will try to game it with fake modules, wash usage, and sybil identities.
- Denial of wallet. If a user's actions cost money, an attacker can try to run up their bill. Caps, limits, and anomaly detection are required, and "this app cost me forty dollars overnight" is the failure that must never happen.
- The central-platform tension. The metering, fair splits, and shared wallet all require a powerful platform sitting in the middle of everything. That central position is both the source of the value and a contradiction of the open, commons-spirited thing it's meant to serve. The platform has to earn its place by being structurally non-extractive rather than by lock-in.
- Other open issues. Trust, safety, and reliability are harder in a shared multi-tenant runtime; some maintenance still works against true set-and-forget; multi-user interactions get complex when responsibility is distributed; a open-source requirement may undermine genuinely proprietary value and; network effects are very difficult to build from zero.
Why It Has to Be Its Own Company
The platform's whole promise is non-extraction — thin, visible margins, no extractive ad model, the user as customer, money shared rather than captured. These are commitments about incentives, not features, and they can't be bolted onto an entity with an existing extractive business to protect. The Substrate must be built from zero, with the company's structure engineered as carefully as the platform itself: steward ownership, a capped or purpose-bound return, and a charter that hard-codes the core commitments deeply enough that no future board can quietly undo them. The founder's incentives have to mirror the platform's, or the alignment is just marketing.
Thin margins aren't a sacrifice here; they are the mechanism. A closed market at fifty-percent margins has a hard ceiling, while an open market at one-percent margins has none, — one percent of an unbounded market returns more, to everyone, than half of a captured one.
The obvious objection is that a blockchain already does this. But blockchains buy trustlessness with exactly the properties this platform depends on not having: they are slow, expensive, inefficient, and unregulated.
That openness hands the platform enormous responsibility, and standing in the execution path of everything is real power. Being better than the incumbents does not, by itself, grant the right to seize control and dictate how things should be. A truly trustless system is technically impossible, so the platform can't promise trustlessness — its core axiom has to be trustworthiness.
Why Now
Public trust in technology has worn thin, much of it for good reason — and that erosion is exactly the appetite web3 tried to capture: a widely shared desire for software that is open, user-owned, and aligned to the people using it rather than to advertisers and investors. The wish was real even where the technology beneath it couldn't deliver. The Substrate aims at that same desire with an approach that can actually keep the promise, and three concrete conditions are now aligning for the first time to make it possible:
- The infrastructure is ready. Running thousands of strangers' apps safely and cheaply, scaling to zero with no idle cost, now exists in production rather than research.
- The Cambrian Explosion of software is here. AI is producing a wave of useful-but-uncompanyable software that breaks the old funding models. Simultaneously, it is making per-user operation costly and variable, which is dragging the whole industry from flat subscriptions toward the usage-based, metered pricing The Substrate is built around — the model is being validated from the outside, in real time.
- Agents dissolve the micro-transaction objection. That objection assumes a human paying the mental cost of each tiny decision. Software increasingly operated by agents has no such cost — an agent can weigh "is this worth a fraction of a cent" endlessly without fatigue. For machines settling up with each other, pay-per-use stops being a tax on attention and becomes the natural way they transact.