Reactive Model Composition

The Composing Agent Decides How Parts Fit

Every larger structure needs an agent that decides how its pieces fit. A document parent places child regions. A circuit region assigns resources and connects subcircuit ports. A distributed orchestrator allocates processes and establishes routes.

The composing agent owns membership, placement, attachment, replacement, and release. Constituents perform their own work and exchange ordinary data directly after the owner connects them.

Composition authority therefore differs from data-path authority. The program that authorizes two streams can leave their subsequent traffic on a peer-to-peer path.

Give Every Composition Fact One Owner

Several composers can coexist without forming one global hierarchy. A protocol must order any decisions that affect the same port, region, or connection.

When two agents simultaneously choose what occupies the same space, the system receives a write conflict rather than meaningful decentralization.

Ownership makes the conflict local and answerable:

• Who may allocate this region?
• Who may install a new program here?
• Who may expose or connect this port?
• Who may cut, redirect, or release the connection?
• When does transferred authority take effect?

A system can transfer ownership, subdivide it, or represent it with a tree. Every mutation still needs an authorized origin and a defined completion moment.

Composition Arrives Through Finite Channels

A physical channel delivers a sequence of symbols through time. Wide buses still have finite width, and shared-memory updates still reach storage through finite circuitry.

A composition stream therefore carries explicit changes: allocate, describe, connect, initialize, commit, and release. A receiver can collect those changes in private staging state and reveal them together after the final symbol arrives.

A completion condition and apply step keep the active program coherent while its replacement arrives. Staging prevents a half-old, half-new description from entering the application plane.

Cartilage makes this operation physical. A bounded child region receives configuration records through its local port and ownership route. An apply event installs the new cell roles. The same kind of cells that perform application computation also carry and retain configuration traffic.

Attachment Points Preserve Ownership

User interfaces express the same architecture in softer material. A parent view determines the frame around a child while the child owns the content within it.

The parent describes its own structure and supplies an attachment point. Parent updates preserve the child’s private subtree because the attachment point marks a resource handoff.

Fully unrolled virtual trees repeatedly reproduce every descendant. Their descriptions grow with runtime structure, obscure ownership, and regenerate large trees for local changes.

A compositional description carries types, parameters, identities, and attachment points. Constituents maintain their own state and channels, so independently owned regions assemble the larger view without recopying one giant value.

A Value Can Act As A Program

A value can contain state, Boolean structure, and responses to incoming signals. It becomes an active program instead of a passive record for another machine to interpret.

The program keeps internal state private and communicates selected information through messages. Connected programs build their own models of one another from those exchanges.

A one-bit channel can carry an entire language over time. Framing and a shared protocol let a narrow connection describe structures far larger than one bit while preserving the rest of each program’s state surface.

Reactive propagation follows directly: a private state change initiates the relevant conversations. No global caller needs to walk the whole system and poll every value for staleness.

Separate Code, Deployment, And Program

Three terms carry a description into active use:

Program code

A complete streamable description that initializes one program’s structure and state.

Deployment

The act of carrying that description to an allocated place and installing it.

Program

An active installed instance with private state and communication channels.

A fixed image, parameters, or captured state can produce the program. Construction becomes a deployment operation that consumes channel capacity, space, and time.

A composite program represents a distributed value by coordinating constituents while leaving their private state intact. Its own state records which constituents exist, which resources they occupy, and how their channels connect.

Unallocated Space Already Runs A Program

Space that can accept a program already has behavior. It exposes an address, receives allocation requests, establishes configuration paths, collects deployment streams, recognizes completion, and yields control to the new program.

A compact deployment conversation follows seven steps:

1. An owner requests enough adjacent space for a new program.
2. The space manager identifies a finite region and an attachment point.
3. The owner establishes a configuration route to that region.
4. The code stream travels through the route into staging state.
5. The region reports that the complete description has arrived.
6. An apply event installs the new roles and initial state.
7. The owner connects the new program’s application channels.

Cartilage implements installation through a child-owned local port. A general allocator can extend the same explicit operations to arbitrary space discovery, ownership transfer, port relocation, and live reconnection.

One Bit Can Describe Everything, But Should Not Relay Everything

Given enough time, a narrow channel can carry arbitrarily rich descriptions. Large compositions still need multiple paths for concurrent application traffic.

If every constituent message enters the owner, undergoes decoding and addressing, and exits through the same one-bit opening, the owner becomes a serialization machine. Internal parallelism collapses onto one contested route even when faster serializers raise its ceiling.

bad:
A --\
B --- owner / relay --- external peers
C --/

better:
owner establishes A <--> B
owner establishes B <--> C
application traffic follows those direct channels

Encapsulation protects authority and private state while direct connections preserve constituent bandwidth. The scalable rule is simple:

Manage connections. Do not relay every conversation.

This is as relevant to servers and accelerators as it is to a reconfigurable fabric. A control plane may allocate endpoints and authorize a path while a data plane carries the high-volume stream directly.

Cartilage Makes Composition Physical

Cartilage forms a homogeneous two-dimensional fabric. A finite cell record selects a role such as wire, constant, crossing, multiplexer, or reconfiguration port. Additional state identifies local ownership and carries the configuration transaction.

A parent region maintains a daughter region through a port in the daughter’s ownership tree. A serial stream changes the daughter’s physical cell roles and installs a new circuit into the same substrate.

Runtime Instantiation In Space makes the spatial operation visible. Cartilage Core carries one installation through a compact browser machine and independent SystemVerilog RTL. The Boolean construction develops the formal path through finite owned regions, local ports, installation, commit, and release.

Placement, reclamation, arbitrary routing, live migration, and program generation can now become fabric-resident algorithms whose state and authority remain visible beside the circuits they change.

Rules for a Reactive Composer

1. Give each mutable composition fact an explicit owner.
2. Keep constituent state private; communicate through defined channels.
3. Represent installation as a finite stream with completion and apply phases.
4. Make attachment points first-class resources.
5. Treat unallocated space as an active participant in allocation.
6. Separate the control path that establishes a connection from the data path that uses it.
7. Do not regenerate or proxy structure that another program already owns.
8. Measure channel contention before declaring a narrow interface elegant.

These rules define a common language for composition wherever state has a place, change takes time, and one active structure creates another.