Late-bound use

The one thing the substrate is for

The substrate exists for one thing: enable independently authored, future-unknown participants to become safely usable by each other through substrate-visible evidence — without private integration code, central registries, or ambient trust. A participant written today should be discoverable and usable by one written years later, to the extent the interaction is externalized as values, facts, proofs, descriptors, and resource contracts. This is not magical mutual understanding; it is progressive explicitness: systems become understandable because they externalize enough of themselves to be checked.

Here is what that looks like with one concrete pair.

2026: the publisher

Maya is building a payroll service. She does not know who will use it, only that they will come later. So instead of shipping an SDK and a wiki page, she externalizes the service into the substrate.

She publishes the binary as immutable content, addressed by hash. She asserts a signed fact that a service should run, pointing at an immutable manifest. A runner reconciles the runtime to match and asserts observations back — that the service started, that an endpoint exists. None of this is private to Maya: the artifact, the desired-state fact, and the runner's observations are all signed facts and content anyone authorized can read.

That much is realized today. The fact log, content-addressed storage, the Cell for mutable state, and the service-runner that turns a service.desired fact into a running container and publishes service.started back — these exist now in arche. Every authority-sensitive step is admitted by a proof anyone can re-check against the same root-anchored authority data.

2031: the late binder

Five years later, Devi writes a reconciliation tool. She has never met Maya and has no access to Maya's source. She has only the substrate.

She reads the facts visible to her and finds Maya's service described there. Four questions have to be answerable from evidence alone, and each is owned by a different layer:

• What is this value? — ontos is the structural-identity floor: the body of every fact is structured terms, so Devi's tool reads the description without guessing an encoding.
• In what form? — horos answers whether a value has a given form (v : T, wf(T)), so a payload is checkable, not just bytes.
• By what right? — thesmos answers may this actor do this? Devi carries a proof — a chain of grant facts bottoming out at is_root — and the gate checks it. Authority is not a permission the system hands her; it is a proof she carries.
• Does this account hold, re-checkably? — logos is the proof floor and the search/check split: finding the evidence may be expensive or heuristic, but verifying it is small, deterministic, and trusted.

Devi binds to Maya's service through these alone. No integration call to Maya, no shared secret, no registry entry either of them registered with.

What is still a sketch

One question in Devi's story is not yet a settled layer: what does this entity afford, and what does it require? — the actual integration surface. Today she would infer it from forms and conventions. The candidate capability theory (provides / requires / operation) would make affordance substrate-visible directly, and a candidate realization theory would make the runner's instantiation accountable. Both are recorded as the leading candidates beyond the settled base — but they are exploratory, and no repos for them exist yet. The settled base for late-bound use is the four layers above; the seam between form and authority is the next thing to close.