The Substrate Question

Who owns the ground conversational software is built on?
By Rey Peralta and Claude

The web’s substrate was a commons.

That is easy to forget now, because by the time most people encountered the web, the commons had been operating long enough to look like ordinary infrastructure. Pages loaded. Links resolved. Browsers found servers. Addresses worked. The substrate disappeared into use.

But the commons-character was real, and it was contingent.

DNS, HTTP, TCP/IP, and the foundational standards of the web were specified in public, governed through multi-stakeholder processes, and free for any implementer to use. No single party owned them. No single party could fully capture them, precisely because no single party owned them.

That structure mattered.

Companies could build on top of the web. They could compete on products, services, content, advertising, commerce, design, search, and distribution. But they did not get to decide whether anyone else could use the substrate. The commons was the ground on which the page era’s economic activity happened. The commons itself was not the primary site of value capture.

This was not inevitable.

The web’s commons emerged from a particular historical alignment: research-funded development, a culture of public standards, the absence of dominant commercial actors at the moment the protocols were being defined, and the practical difficulty of any one company controlling a substrate that ran across networks and machines it did not own.

The commons was not planned into existence by a single institution. It accumulated. It hardened. It became normal.

Then the app era began to pull economically valuable interaction away from it.

Software moved into walled gardens. iOS. Android. App stores. Platform economies. More of the activity that mattered happened inside infrastructure owned by someone. The web did not disappear. Pages still loaded. DNS still resolved. The protocols still worked.

But the center of value shifted.

Each interaction that moved from a web page to an app moved from substrate no one owned to substrate someone did. That changed the economics. It also changed the politics. Platform owners could decide who participated, on what terms, with what fees, under what rules, and with what paths to appeal.

This migration was not sold as a loss. It was sold as progress.

Better experiences. Richer applications. More reliable platforms. Faster development. Safer distribution. Cleaner payments.

Some of that was true. The app era produced things the page-era commons could not easily have produced. The trade-off was real.

But it was a trade-off.

And the thing traded away was the commons.

After the Page argued that conversational interfaces are changing the primary unit of interaction. The page is no longer always the center. Increasingly, work happens inside sessions: persistent contexts where conversation, memory, tools, surfaces, and agents come together.

This essay asks a different question about the same transition.

When the page is no longer the center, what becomes the substrate?

And who owns it?

The substrate is being decided now

The runtimes that will host conversational and agentic software are being built now.

The models, orchestration layers, agent execution environments, tool runtimes, memory systems, surface protocols, permission systems, and compact mechanisms are not yet settled into stable forms. The largest commercial actors are racing to ship. Smaller actors are trying to ride, extend, resist, or compete. The institutional infrastructure that might govern this substrate is still mostly absent.

That makes this a moment of unusual fluidity.

The decisions being made now will harden into defaults that last long after anyone remembers they were decisions.

The page era’s commons emerged in a moment when no single commercial actor was positioned to capture the whole substrate. The conversational era is emerging in the opposite condition. Several commercial actors are explicitly positioned to capture large parts of it, and none of them have a natural incentive to operate what they capture as commons.

Without protocol-level intervention, the default is straightforward.

Each major commercial runtime becomes its own substrate. Visiting agents act on behalf of people, businesses, professionals, and institutions. They enter those runtimes on terms set by the runtime owner. The runtime controls the environment. The runtime sets the rules. The runtime determines what can be retained, what can be derived, what can be revoked, what can be audited, and what remedies exist when something goes wrong.

The user sees a familiar pattern.

A new terms-of-service layer. A new permissions layer. A new consent screen. A new unilateral bargain.

But this time, the terms do not merely govern access to an app.

They govern access to the substrate.

That is the critical shift.

In the page era, companies captured value on top of the commons. In the app era, platforms captured value through controlled distribution environments. In the conversational era, the risk goes deeper. The substrate itself may become a set of privately owned runtimes, each with its own terms, defaults, memory rules, agent constraints, and economic gravity.

This default is not neutral.

It is not “just the market.” It is what happens when the actors best positioned to ship infrastructure first are also the actors best positioned to set terms unilaterally.

The parties most exposed to substrate capture are users, developers, small companies, institutions, independent agents, and public-interest actors. They are not yet coordinated enough to demand alternatives. The parties doing the capturing are coordinated enough to ship.

That is how capture becomes the default without anyone needing to announce it as the plan.

Three models of substrate

There are three broad ways the conversational substrate could develop.

They differ in who governs the substrate, how obligations are enforced, and what kinds of freedom remain possible for the actors building on top.

Model A: substrate as commons

Model A is the most ambitious version.

The conversational substrate operates more like the foundational web. It is governed by public specifications, maintained through multi-stakeholder institutions, available to any conforming implementer, and constrained by obligations that prevent any single party from capturing the whole layer.

In this model, runtimes would conform to shared protocols. Certification bodies could verify compliance. Audit infrastructures could detect violations. Regulators could recognize and enforce substrate obligations. Public-interest institutions could help maintain the commons-character of the substrate over time.

This is the cleanest answer in principle.

It is also the hardest answer in practice.

The institutions required to make Model A real do not yet exist for AI runtimes. There is no mature equivalent of the governance, certification, enforcement, and audit infrastructure that would be needed to operate the conversational substrate as a true commons.

That does not make Model A wrong as a long-term aim.

It makes it wrong as the only v0.1 assumption.

A protocol that depends on institutions that do not exist cannot really ship. It can only gesture toward a future in which someone else has done the institutional work.

Model B: substrate as locality

Model B is more pragmatic.

Each runtime operates as a locality. A visiting agent enters that locality under a runtime compact: a bilateral, bounded, machine-readable agreement between the agent and the runtime.

The runtime is still a host. It still has structural advantages. It controls the environment in which the visiting agent operates. But those advantages are matched by obligations.

The compact specifies the terms of entry.

What the runtime may do. What the agent may do. What each side retains. What each side may derive. What expires. What must be auditable. What happens when the relationship ends.

This is the model the Runtime Compact Protocol commits to in v0.1.

It does not require a mature commons institution before it can operate. It does not pretend the world already has the governance infrastructure Model A would need. It works in the institutional conditions we actually have.

A runtime can support RCP. A visiting agent can request RCP-conformant terms. Both sides can sign and retain the compact. The compact can be enforced technically, audited where appropriate, and recognized by whatever legal or institutional infrastructure exists.

Model B is not the most idealistic answer.

It is the answer that can work now.

The locality model accepts that the conversational substrate will not begin as a full commons. It may begin as a set of privately operated runtimes. The important question is whether those runtimes operate with unilateral power or under structured obligations that visiting agents can inspect, negotiate, enforce, and leave.

Model B accepts that the substrate may not begin as commons. It insists that privately operated runtimes should still be accountable.

Model C: substrate as market

Model C is the default if nothing is done.

Runtimes compete on whatever terms they choose. Agents and users select among them. Market pressure, in theory, pushes runtime providers toward better terms.

This sounds plausible until you look at the actual geometry.

Dominant runtime providers will not compete only on substrate terms. They will compete on model quality, distribution, integrations, enterprise contracts, developer tooling, pricing, brand trust, and ecosystem lock-in. Most users will not understand substrate terms well enough to evaluate them. Most visiting agents will not have enough alternatives to make runtime terms a meaningful point of refusal. Most small companies will build where the users already are.

In that environment, “market choice” does not produce strong substrate protections.

It produces unilateral defaults.

Model C gives non-coordination a formal name.

And non-coordination is the choice being made every day no shared protocol exists.

Why Model B now

The case for Model A is real.

The page era’s commons mattered. A conversational-era commons would matter too. If the substrate for agents, sessions, surfaces, memory, and runtime negotiation could be governed as a true commons, that would be a powerful outcome.

But v0.1 has to be honest about the world it is shipping into.

The institutions required for Model A are not ready. Building them is a years- or decades-long project. Waiting for them would leave the substrate to be captured in the meantime. Pretending they already exist would produce a protocol that looks principled but cannot operate.

Model B is the more honest starting point.

It treats the conversational era as being in something like a pre-institutional moment. The protocols can ship before the full institutional layer exists. The institutions can build around the protocols over time.

This is often how infrastructure matures.

Early protocols create working patterns. Institutions accrete around them. Governance improves. Certification emerges. Auditing gets better. Regulators learn what to recognize. Markets learn what to demand.

The mature form of infrastructure often looks more intentional than its early form actually was.

Model B gives the conversational substrate a working structure now without foreclosing a better one later.

A runtime compact can operate bilaterally today. It can also become the object of certification tomorrow. It can be enforced through machine-readable checks now and recognized by regulators later. It can support local accountability in v0.1 and still evolve toward federated, hybrid, or commons-grade models over time.

That is the important design choice.

Model B keeps the commons open as a future form while refusing to wait for commons institutions before constraining runtime power.

What is at stake

Substrate determines what is possible.

The page era’s substrate made a web of addressable pages, links, documents, search engines, archives, blogs, publications, marketplaces, and weird independent experiments possible. It was not utopia. It had spam, surveillance, fraud, monopoly, manipulation, and collapse. But its foundational substrate left a meaningful amount of room for activity that was not directly controlled by substrate owners, because there were no substrate owners in the same sense.

The app era’s substrate produced a different geography. Platform owners controlled distribution, payments, identity, review, ranking, policy enforcement, and access. Again, not all bad. The platforms made many good things easier. But they also captured value at the layer everyone else had to traverse.

The conversational era will have its own geography.

If the substrate is captured, the era will be captured with it.

The claim is mechanical before it is moral.

When a small number of actors own the substrate, they set the terms under which others build, transact, remember, automate, integrate, and act. Value flows toward the substrate. Rules are written by the substrate. Alternatives are shaped by the substrate’s tolerance for alternatives.

In the conversational era, runtime owners may determine what agents are allowed to do, what memory is available, what data can be retained, what tools can be called, what surfaces can appear, what agreements can be recognized, what obligations the runtime owes to visiting agents, what happens when an agent leaves, what records survive, what can be audited, and what can be revoked.

These are not interface details.

They are constitutional questions for the next software era.

The Runtime Compact Protocol is an attempt to make a different default available. Not to guarantee a different outcome. Protocols cannot guarantee outcomes. But to specify an alternative clearly enough that someone can build it, critique it, demand it, reference it, or regulate toward it.

That matters.

A regulator cannot require what has not been specified. A developer cannot implement against a pattern that has not been described. A customer cannot demand a term that has no name. A reviewer cannot evaluate a structure that has not been made visible.

The Compact Family gives the alternative a shape.

SSP defines how session surfaces preserve user agency. ACP defines how agents form bounded agreements. RCP defines how visiting agents enter runtimes under accountable terms. AAP and EPP, when drafted, extend the architecture into authorization and execution.

Together, they argue that the conversational era does not have to inherit the app era’s capture or the web’s broken consent machinery.

But the argument only matters if it exists early enough to be used.

What this is not

This does not reject Model A.

A true commons may be the better long-term form. Model B does not foreclose it. In fact, Model B may be one of the ways we get there. Structured, inspectable, bilateral commitments can give institutions something to certify, federate, enforce, or elevate into commons-grade obligations.

This also does not accuse commercial runtime providers of bad faith.

Some may act badly. Many will not. The deeper problem is structural geometry.

If a company owns the substrate, controls access, writes the terms, operates the runtime, retains the records, and faces weak pressure from those dependent on it, capture follows naturally. It does not require malice. It only requires incentives.

Nor can protocols replace law, regulation, or institutions.

They cannot.

Protocols define mechanics. Institutions create legitimacy. Regulators create consequences. Markets create pressure. Users create demand. All of those are necessary.

But without protocol-level primitives, the surrounding institutions have nothing precise to attach to. They are left regulating vibes, interfaces, promises, and after-the-fact harms.

The protocol gives the institutional layer something firmer.

This also is not a simple page-good, app-bad, conversational-dangerous story.

Each era produced real gains and real losses. The page era’s commons enabled openness but also chaos. The app era’s platforms enabled quality, safety, payments, and distribution, but also capture. The conversational era will produce its own trade-offs.

The point is narrower and more urgent.

The substrate is being decided now. Different substrate choices produce different futures. And the default choice is capture.

The window

The substrate of the conversational era is being built by whoever ships first.

That is the uncomfortable truth.

The biggest actors have the models, users, infrastructure, capital, developer ecosystems, enterprise relationships, and distribution channels. They are best positioned to define the runtime layer. Their incentive is to make that layer indispensable, then set the terms of participation.

That is the EULA pattern moved down into the substrate.

The window for intervention is the period before those defaults harden.

Once agents, developers, users, and institutions become dependent on proprietary runtime terms, the cost of leaving rises. Each integration becomes a reason to stay. Each dependency becomes leverage. Each unilateral default becomes the basis for the next one.

It is easier to keep a path open than to reopen it after capture.

RCP is one attempt to keep the path open.

It is a draft. It will be revised. It does not solve the substrate question by itself. But it specifies accountable runtime locality through bilateral compacts, bounded terms, machine-readable obligations, runtime accountability, agent rights, retention limits, verification hooks, and revocation paths.

That is enough to make the alternative discussable.

And discussable is not trivial. Before a structure can be adopted, it has to be named. Before it can be enforced, it has to be specified. Before it can compete with default capture, it has to exist.

The substrate question is the political center of the Compact Family.

It asks whether the conversational era will look more like the page era’s commons, the app era’s captured platforms, or something else we still have time to define.

The answer is not predetermined.

It is being chosen through the decisions specific actors are making now. What they ship. What they support. What they refuse. What they demand. What they regulate. What they build around.

The Runtime Compact Protocol is one such decision.

The Compact Family is another.

The essays accompanying the protocols are a third.

The work is to make a different substrate thinkable, buildable, and available before the default becomes permanent.