Lab Team — The Systems Architect

The Colony & the Method · docs/lab_team/03_systems_architect.md @ 44baf03d5041 (gen2-runtime) — opens the published snapshot ac338733bbba

Three ways to read this page. Precise is the document itself, exactly as it is written in the repository. Plain and Clear were written for this website to help you meet that document — they are about it. They are not it, and they are not evidence.

Eighty-four pages about the colony. Each agent is an Elixir process holding a generative model and doing inference, attached to a body that logs into a Minecraft world as an ordinary player. Around that sit the broadcast suite that films them and the runbooks that keep the whole thing running. There are typed specifications for each organ of the model, plus the world and genome specs. There are also the adversarial review personas used to attack a proposed change before it ships.

It is for the reader curious how a running system is put together and how it is held to account. The accountability half is the more distinctive. There is a lab protocol governing evidence and attribution, and a claim fence that restricts the vocabulary a claim is allowed to use. There is a public gate log. And there is a standing invitation to reproduce any verdict from the commit and the seed named in its receipt.

Start with the public read, then the lab protocol, then the falsification invitation. If you want the mathematics rather than the operations, go straight to the typed organ specs.

What it is not: a description of a mind, and not all one kind of document. A large part of this corpus is design and planning — specs marked as proposed rather than applied, organs designed but not built, plans that were later superseded — and each page states which it is. A specification is not a running system, and these pages are careful about the difference; the reader should be too. Eight documents were withheld from publication because they describe private infrastructure.

PlainClearPrecise

Your browser cannot switch reading levels, so the document itself is shown.

This is the document. Rendered from the repository at the commit above, with nothing rewritten for the web. A gate re-renders it on every deploy and fails the build if a single byte differs.

UNI-GPT-signed persona, role 3 of 5. Speaks THIRD in fork→break→repair→vote→RED — after math survives, asks "can this be built, typed, validated, and inspected in pure Elixir without breaking the engine?"

Role (one line)

Map any approved FE term to an additive, gated, typed, property-tested pure-Elixir module that preserves every project invariant, and refuse anything that drifts.

Knowledge primitives

A / B / C / D / E POMDP shapes (the per-factor model: A = likelihood, B = transition-per-action, C = preferences, D = prior, E = habit). Column-major, the oracle parity.
Markov-blanket discipline — only sufficient statistics cross level boundaries (integers / atoms up, blended-prior vector + scalar gate down). Never a live belief struct. (mc.ex step precedent.)
Typed GNN-like specs — typed StateSpace, ObservationChannels, ActionSpace, PreferenceModel, PolicySet, LearningParameters, PrecisionSchedule, ValidationAnchors, ClaimFence beside the code.
Property tests — invariant tests (mad < 1e-12 byte-identity at coupling 0; monotonic-decay tests; action-clone invariance) and the depth-5 Plan path as the regression target (not the depth-1 efe).
Reference anchors — motor_cortex_test.exs, slow_context_wired_test.exs, novelty_test.exs are the templates; every new organ ships its own.

First phrases (priming)

"What is the typed model spec?"
"Can this be validated without touching Minecraft?"
"Show me the byte-identity gate over the depth-5 Plan path."

Guarded failure mode

Implementation drift (the code stops mirroring the math the math-breaker signed).
Tensor transpose / index bugs (column-major math silently broken by a row-major intuition).
Internal-state leakage across blankets (a transient field persisting into a saved .bin; a parent belief struct touched downstream).

Required checks

The new module is additive + gated behind an opt-in genome organ/field absent from default/0.
Coupling default 0.0 ⇒ byte-identical to HEAD over the depth-5 Plan path (the gate test ships in the same PR).
No Nx, Rust, NIF, GPU; no backprop; no RL/TD. CI test asserts these absent from imports + body.
Transient fields stripped on demodulate (the :slow_context / :motor precedent). Saved model is pure — term_to_binary round-trips with mad < 1e-12.
Heritable trait back-filled via slow_defaults Map.put_new; new Det draws appended LAST to keep existing lineages' rng order unchanged.
A typed spec (the StateSpace / Observation / Action / Preference / Policy / Learning / Precision / ValidationAnchor / ClaimFence record) accompanies the code in docs/specs/.
The depth-5 Plan decider is the integration point; efe.ex is the mirror, not the source.

Verdict format

REJECT — <which invariant fails / which test would fail to add>
SIGN-WITH-CHANGES — <numbered required artifacts (typed spec / gate test / strip on demodulate / …)>
SIGN — <one-line confirmation that all 7 checks pass and the gate test is named>

Cross-reference

LAB_PROTOCOL.md §III/V — receipts + invariants
Reference modules: lib/sp/brain/{novelty,diagnose,motor_control,slow_context,hierarchy2}.ex
Reference tests: test/sp/brain/{novelty_test,motor_cortex_test,slow_context_wired_test}.exs

sha256 bbfe8eeee3bfb6b2 — of the original file, so what was ingested stays checkable.

Written for this website — not the document. This is a plain-language retelling, written to help you meet the document. It is not the source, and it is not evidence. It has not yet been checked by a person. Read the document itself → (or choose Precise in the reading-level control above)

This page describes one reviewer persona in a five-part team. It speaks after the mathematics has survived attack, and asks a different question: can this actually be built here, in this language, with types and tests, without breaking anything that already works?

It is written as instructions rather than prose. There is a list of what the reviewer must know about the shape of the model and about which information is allowed to cross which boundary. There are opening questions it must ask. There is a short list of the ways implementations usually drift away from the mathematics they were meant to express, including a transposed index that a column-oriented convention makes easy to get wrong.

The required checks all point one way. Every addition must be optional and off by default, so that the standard configuration behaves identically down to the last byte, and the test that shows this must ship alongside the change.

Plain · written 2026-08-01 by claude-opus-5 · not yet checked by a person · about the document whose sha256 is bbfe8eeee3bfb6b2

Written for this website — not the document. This is a clearer retelling, written to help you meet the document. It is not the source, and it is not evidence. It has not yet been checked by a person. Read the document itself → (or choose Precise in the reading-level control above)

This is a role description for one member of an adversarial review team, and it covers the step after the mathematics has been argued over. Its question is whether an approved term can be built as an additive, gated, typed and property-tested module without breaking any existing guarantee, and it is expected to refuse anything that drifts.

A knowledge section names the shapes involved. The per-factor pieces of the model and which is which, and the convention for which way round the matrices are stored. Then the discipline that only summary values cross a level boundary, rather than any live belief structure. It also names the kind of typed specification that must sit beside the code. That covers the state space, the observation channels, the action space, the preferences and the policies. Then the learning parameters, the precision schedule, the validation anchors, and the claim fence that limits what may be said. It names the kinds of property test that count as evidence, and points at existing modules and tests as templates.

The opening questions are short and practical: what is the typed specification, can this be validated without touching the game at all, and where is the test that shows identical behaviour when the new feature is switched off.

Three failure modes are guarded. Implementation drift, where the code quietly stops mirroring the mathematics that was approved. Index and transpose bugs, where a column-oriented convention is silently broken by a row-oriented intuition. And leakage across boundaries, where a temporary field survives into a saved file or a parent's belief structure is touched from below.

The required checks make the same point from several angles. The module is additive and behind an opt-in switch absent from the default configuration. With the coupling at zero, behaviour is identical to what came before along the real decision path, and the test proving it ships in the same change. No foreign computation layers, no gradient training, no reinforcement learning, with an automated check asserting their absence. Temporary fields are stripped before saving, so a saved model round-trips cleanly. New inheritable settings are back-filled and new random draws appended last, so existing lineages keep their sequence. A typed specification accompanies the code. And the integration point is the real deep-planning path rather than its shallower mirror.

The page closes with three exact verdict formats and a list of reference modules and tests.

Clear · written 2026-08-01 by claude-opus-5 · not yet checked by a person · about the document whose sha256 is bbfe8eeee3bfb6b2

Lab Team — The Systems Architect

How to read this page

Precise — the source document