Build with UNI

A model here is declared, compiled, then run. You write a card — what it can sense, what it can do, what it prefers, how sharply it weighs each sense — and a compiler turns the card into a runnable model whose behaviour can be checked back against what you declared. A card, not a checkpoint. Nothing is trained in the dark.

The Function Designer Card

In the colony engine, a model begins as a declarative card. The card names the model’s sensory modalities and the hidden states behind each, its action set, its preferences over outcomes, a precision per modality, and which parts it is allowed to learn. compile/1turns the card into a runnable factor model. The genome that expresses the colony’s survival agent is not a special case: it is one card, compiled by the same function and checked by the same validation gates as any card you would write yourself. The module’s own documentation says it more precisely:

The universal-builder front-end (§spec "Function Designer Card"). A **card** is a
declarative description of a function — its sensory modalities, hidden causes,
action set, preferences, precision rules and learning flags — and `compile/1`
turns it into a runnable `SP.Brain.Factors` model. This generalises the genome:
`SP.Brain.Genome.express/1` is now just `compile(Genome.card(dna))`, so the
5-modality survival agent is simply *one card*, and any new function (a nociception
reflex, a self-model, a strategic layer) is *another card* compiled the same way
and checked by the same validation gates.

The same moduledoc carries the boundary this estate holds everywhere, and it belongs on this page more than any feature does:

We test ADEQUACY (does the compiled model behave as
the card specifies?) — we never claim the card *is* the biological function.

The working repository is private. The quotes above were read out of the public mirror’s own tree at commit 84fb968f5dba, so what the link opens is byte-for-byte what is printed here — not a paraphrase of something you cannot check.

The visual builder

The Workbench is the fully public half, and its Agent Builder is where the same idea gets a surface you can drag things onto. At the pinned commit, the builder is a LiveView mounted at /builder/new and /builder/:spec_id. Its own documentation describes the flow, and the description matches the code beneath it:

Three panes, left-to-right:
- Palette: draggable cards (archetypes + block types). HTML5 drag-and-drop
  from card → canvas emits `add_node`.
- Canvas: `litegraph.js` node editor mounted via the `CompositionCanvas`
  JS hook. Topology JSON round-trips between the hook and the server on
  every drag/connect/param edit. Clicking a node emits `select_node`.
- Inspector: schema-bound form for the selected node, backed by
  `WorldModels.Spec.BlockSchema`. Every edit is validated server-side;
  errors surface inline.

Save persists a `WorldModels.Spec`; Instantiate spins up a supervised
`Jido.AgentServer` via `AgentPlane.Runtime.start_agent/1` and redirects
to `/glass/agent/:agent_id`.

In plain words: a palette of building blocks on the left, a canvas in the middle where dragging a block adds a node and wiring nodes builds a topology, and an inspector on the right whose form is bound to a schema — so a bad parameter is refused at edit time, with the error shown inline, rather than discovered at run time. Save persists a Spec. Instantiate boots a live, supervised agent server process from that Spec and sends you to its glass page to watch it run. The thing you drew is the thing that runs, and the glass page is where that claim gets tested against your own eyes.

The repository is public and the run is local — no GPU, no accounts. The run instructions live on the course page and are not duplicated here: a command printed in two places is a command that rots in one of them.

The discipline that binds every build

Any proposed addition to the engine’s mathematics — anything that touches the free energy — faces an adversarial review before it becomes code. The derivation comes first, and the falsifier is named before the implementation is written; the review’s default answer is no. What survives goes behind gates that run before merge. What fails is kept and published, because a record of only the wins is advertising. declared — this is a protocol people follow, not a property a program can measure

What canbe checked is the protocol’s residue. The protocol itself is written down at docs/LAB_PROTOCOL.md in the same repository as the card compiler (mirror copy @ 84fb968f5dba). The gate registry and its results are at the gates page. The record of what was tried and lost — falsified predictions, retracted claims, defects kept on the wall on purpose — is at the wrong page, and it is presented first in this estate’s own accounting, never as a footnote.

What building is not, here

No gradient descent. There is no training loop to babysit and no opaque checkpoint to trust at the end of it. The parts of a card that learn — a likelihood, a transition — update by accumulating evidence, in code you can read, while the model runs.

No dataset scraping. A card declares its own observation space; the model meets the world it is put into. Nothing is harvested to make one.

No prompt engineering. There is no language model in the runtime to prompt. Not an LLM carries that claim properly, with what it does and does not cover.

The model you build is the model you can read: the card is short enough to read whole, the compiler is a single module you can open at the commit quoted above, and the compiled structure is inspectable while it runs. That is the whole trade this estate makes — it gives up the reach of a trained black box to keep the right to check every claim against the thing itself.

Want to build here rather than only read? Contribute says how an outside builder joins and what the review will demand of the work. For the doors to every repository this page draws from, walk the hallway.