An earlier formulation of the ideas in what-becomes-true. See also sync.parc.land, surfaces-as-substrate, pressure-field.

The Substrate Thesis

You Are the Component: Surfaces, State, and the Architecture of Emergent Experience

Abstract

Modern software separates use, construction, and reasoning into distinct systems: interfaces for users, code for developers, and increasingly agents for intelligence. This separation produces brittle orchestration, rigid workflows, and tools that cannot evolve alongside intention.

Across three experimental systems — ctxl, sync, and playtest — a different model emerges:

Software is not a sequence of flows but a shared substrate of truth observed by self-activating components.

In this model:

• state is the substrate,
• surfaces are observers,
• actions are transitions,
• and agents and humans become equivalent participants in a reactive cognitive environment.

The interface stops being a controller and becomes a perceptual layer. Experiences are not executed — they emerge.

1. The Original Problem: The Stupid Loop (ctxl)

The starting observation in ctxl is deceptively simple:

People need tools they cannot build because building tools requires programming — itself a tool.

This produces what You Are the Component calls the stupid loop:

need tool → must program → need tool to program → repeat

Traditional LLM tooling attempts to break this via generation:

prompt → generate UI → use result

But generated interfaces are snapshots. They freeze intent at a moment in time.

Intent, however, is not static. It evolves through interaction.

The key insight of ctxl is therefore not generation but malleability:

The interface must remain alive to reasoning.

This leads to the architectural inversion:

Instead of:

Component → occasionally calls AI

ctxl proposes:

AI reasoning participates inside the component lifecycle.

Reasoning becomes a reactive hook. The component does not use intelligence. The component is intelligent.

Hence: You Are the Component.

2. From Intelligent Components to Shared Reality (sync)

ctxl solves local malleability — a single adaptive component.

sync asks the next question:

What happens when many intelligent components share the same world?

Here the architecture shifts from component lifecycle to shared state substrate.

sync introduces a persistent, multiplayer truth layer: shared collections, reactive updates, distributed observers, CRDT-like convergence.

The critical shift:

The UI is no longer primary. State becomes primary reality.

Participants — human or agent — observe and modify a common substrate.

This rediscovery echoes historical systems: blackboard architectures, Linda tuple spaces, reactive databases, collaborative editors. But with a crucial difference:

Earlier systems assumed rigid schemas and deterministic programs. sync assumes open-world semantics and interpretive agents.

State is allowed to grow organically. Absence becomes meaningful.

3. The Failure of Flow Thinking (playtest)

The playtest experiments exposed a structural mismatch.

Attempts to design experiences using traditional logic produced: compound boolean gates, history-dependent visibility, coupled transitions, fragile orchestration. Symptoms of trying to build a state machine atop a reactive substrate.

The discovery:

Experiences built on shared truth behave like ecosystems, not programs.

This leads to the formulation of Surfaces as Substrate.

A surface is defined as:

A declarative observer of shared state that activates itself when relevant.

No controller decides what appears. Each surface carries its own activation contract.

STATE → surfaces evaluate → experience assembles

The system behaves like a coral reef: components respond locally, structure emerges globally.

4. The Unified Model

Across all three projects, the same structure appears at different scales.

They unify into a single architecture:

            Humans / Agents
                    ↑
                Surfaces
                    ↑
            Derived Meaning
                    ↑
                 State
                    ↑
         Localized State Machines

5. Events vs Reality

Traditional systems preserve history as truth. The substrate model distinguishes:

• events — how change occurred
• facts — what is currently true

found_key = true        ← event fossil
inventory includes key  ← world fact

Surfaces depend only on facts. Actions may internally emit events but must externally commit ontology.

This mirrors CQRS and event sourcing — but reverses priority:

The projection is reality. The log is implementation.

6. Interpretation as First-Class Layer

A critical evolution emerges when scaling to agents. Raw state is too granular for perception. Meaning must be derived.

inventory contains rope
+ at == cabin
→ can_descend_well

Derived facts form a semantic compression layer: humans perceive affordances naturally; agents require them explicitly.

Thus interpretation becomes a declarative layer of the substrate itself.

7. State Machines Become Organs

Pure reactive systems struggle with exclusivity: transactions, locks, atomic exchanges.

The solution is not abandoning state machines but localizing them.

State machines operate as bounded organs:

organ resolves constraint → emits updated fact → reef reacts

The ecosystem never sees the imperative mechanics. Only the resulting truth propagates.

8. Interface = Perception

When surfaces observe shared truth, UI elements, dashboards, and agent APIs all become equivalent sensory organs.

A button for a human and a JSON affordance for an agent are the same surface expressed through different modalities.

The UI and API converge.

The system stops presenting flows and instead exposes possibility space.

9. The Emergent Property

When these principles hold:

• new surfaces can be added without modifying existing ones,
• new actions introduce new realities without rewrites,
• agents and humans collaborate without coordination logic.

Design shifts from scripting behavior to shaping semantic physics.

You no longer design journeys. You design conditions under which journeys can arise.

10. What These Projects Actually Are

Seen together:

They are not separate experiments. They are iterations toward:

A shared cognitive substrate where software, users, and agents co-evolve through observation of truth.

Closing Thesis

Software historically treated interaction as command and response.

The substrate model treats interaction as perception and adaptation.

Programs execute. Ecosystems emerge.

And when components, agents, and humans all observe the same evolving reality, the boundary between using software and creating it dissolves.

You are not operating the system. You are a participant organism inside it.

You are the component.

Christopher · Edinburgh · February 2026