The Common Names

The terrain that determines where water flows, which communities share a resource, and what the physical land enforces without a regulator.

The acequia works because the ditch enforces cooperation. No sheriff needed, no bureaucrat. The terrain is the rule. Substrate governance means the environment enforces what no policy alone ever could.

The preconditions that determine whether a legal action is cognizable at all — not what you are allowed to do, but whether the system will hear the claim.

Standing doctrine isn't about rights — it's about which architectural conditions make a claim legible to the system. No standing, no hearing. The structure precedes the argument. The same logic applies to autonomous agents: before we ask what they're allowed to do, we ask what conditions make their actions legible.

The conditions under which a clinical judgment is considered trustworthy — not what the physician decides, but the environment in which the decision is made.

A surgeon operating outside a sterile field isn't making a choice — the substrate has failed. We don't regulate surgical decisions; we regulate operating conditions. That's the model for autonomous AI: structural conditions, not behavioral mandates.

The conditions — stability, safety, appropriate challenge — that make a learner's potential accessible. Not what is taught, but what makes learning possible.

You cannot legislate academic achievement without attending to conditions: class size, safety, stability. Those are the substrate. Outcomes follow from substrate, not from curriculum mandates. This same reasoning — that you must govern conditions, not just outputs — applies to any system where intelligent behavior emerges.

The rule-structure, boundaries, and norms that make a shared resource sustainable across time — what Elinor Ostrom called the substrate of collective action.

Ostrom won the Nobel Prize for proving that communities self-govern shared resources when the substrate is right — defined membership, clear boundaries, proportional sanctions. KTP is that substrate specification applied to digital systems. The research program is decades old. The application is new.

The load-bearing structure that everything else rests on — what cannot be removed without collapse, and what determines what changes above it can safely be made.

You can renovate an interior without touching the foundation. You cannot remove the foundation without losing the building. Substrate regulation is foundation regulation — it sets what everything built on top can safely do. Regulating AI behavior without addressing substrate is decorating over a cracked foundation.

The matching engine, clearing mechanism, and settlement rules that make a price meaningful — not what traders decide, but the conditions under which trading has predictable consequences.

FDIC insurance didn't regulate what banks invest in. It changed the substrate depositors operate within. Trust didn't require trust — it required architecture. That's the policy model: change the substrate conditions; the behavior follows.

The ritual conditions — time, location, sequence, witness — that make certain kinds of exchange meaningful and binding. Not what is said, but the conditions under which saying it means something.

Oath-taking in court works because the ritual structure creates a cost for lying that informal conversation doesn't carry. The structure is the substrate. Every culture has this. The question for digital governance is: what is the ritual that makes an AI agent's commitment mean something?

The layered rules — TCP/IP, HTTP, TLS — that determine whether data arrives intact, not what data is sent.

HTTPS didn't change what websites say. It changed the substrate under which what they say can be trusted. The protocol layer is the substrate layer. Regulate the protocol; the application behavior follows. This is the model for AI agent governance: define the substrate, not the content.

The kernel-level conditions — memory boundaries, process permissions, interrupt handling — that determine what any program on the system can physically do.

App permissions aren't rules an app follows voluntarily — they're constraints the operating system enforces. The app cannot access your camera if the OS says no, regardless of what the app intends. We need the same for AI agents: not guidelines they agree to follow, but substrate conditions that govern what they can do.

The conditions under which an AI system operates: what it can remember across sessions, whose authority it recognizes, what can correct it, and which actions it can take without confirmation.

We have been regulating what AI systems say. We should be regulating the environment they operate in — what they remember, whose authority they recognize, how errors get corrected. You cannot govern agent behavior without first specifying agent substrate. This is the missing layer.

The root certificate or key infrastructure from which all trust chains derive — a single upstream architectural decision that determines what every downstream system can assume.

Your browser trusts HTTPS because someone decided which certificate authorities to trust. That decision is made once, upstream, and everything else depends on it. That's substrate: an architectural commitment that determines the trust properties of everything built on top. AI needs the same upstream decision about identity.

The structural sum of points where an adversary can enter or extract — a property of the system's architecture, not of its behavior or intentions.

Zero Trust doesn't regulate what attackers do — it changes what the network grants by default. Verify every request; assume no internal safety. The policy is embedded in the architecture. That's substrate security: structural constraints, not behavioral guidelines.

The structural constraints — types, relationships, integrity rules — enforced at the data layer before any application logic runs.

A NOT NULL constraint cannot be overridden by clever application code. The rule is architectural, not advisory. This is the model for AI governance: structural constraints enforced at the substrate layer, not behavioral guidelines the agent agrees to follow.

The foundational structure that determines what laws are legitimate — not what laws say, but the conditions under which lawmaking itself is valid.

The Constitution doesn't tell Congress what to pass. It specifies the conditions under which whatever Congress passes is a law at all. That's substrate governance: the rules about rules, the document above the documents. AI substrate governance is the same move applied one layer down.

The treaty infrastructure, multilateral institutions, and shared norms that make state commitments credible — not what states are permitted to do, but the conditions under which their commitments mean anything.

NATO's Article 5 isn't a rule — it's substrate. It changes what every member state can assume about every other without negotiating each case. The trust is architectural. AI governance across organizational and national boundaries needs the same: not rules about which actions are permitted, but substrate that makes agent commitments credible.

The procedural conditions that must be met before a government action against a person is legitimate — not the outcome of the decision, but the architecture of how decisions are made.

Due process doesn't guarantee a particular outcome. It guarantees a particular structure: notice, opportunity to be heard, a neutral decision-maker. Those structural conditions are the substrate of legitimate authority. When an AI agent makes a consequential decision about a person, the same question applies: what substrate conditions make that decision legitimate?

The prior conditions that determine what can be built where — not regulations on what buildings do, but architectural constraints on what buildings can be.

Zoning doesn't regulate what happens inside a building. It determines what kind of building can exist in a given location. The constraint is upstream and structural. Regulating AI without substrate is like permitting any building in any location and then writing rules about what happens inside.