L1 — Cellular / autopoietic viability & homeostasis
How to read this page
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.
The Cookbook is the method carried out step by step: 34 pages of recipes for building a developmental active-inference SIMULATION — a bounded peek at a toy world, never a person. The front matter says that word is never softened under any pressure, so it is not softened here. The recipes run from the molecular and cellular rungs up through metabolism, motor control, perception, language and metacognition, and on to rungs that are still open questions. Around them sit a set of kitchen rules, a shared pantry of engines and primitives, and a second family of recipes about nature itself — rocks, water, air, stars, DNA, ants, whales, bats, humans.
It is for the reader asking what building this would actually take. Each recipe names its ingredients, the order of work, the tests to run at that stage, and the point at which a step stops being something already carried out and becomes something proposed.
Begin with the front matter and then the kitchen rules. Those two pages fix the honest position and the fence labels that every later recipe leans on, and without them the status markers on a recipe are easy to skim past. After that the recipes can be read in any order.
The nature recipes sit slightly apart and should be read that way. They cite outside science — geology, chemistry, biology, astrophysics — and a nature citation is never a UNI gate: those chapters contain zero UNI claims and raise no rung.
What it is not: a claim that the whole ladder has been cooked. The book recommends the complete recipe and, on the same page, labels every rung by its real state — that tension is deliberate and is the thing the book is built around. Where a recipe and the claim ledger disagree, the ledger wins.
Your browser cannot switch reading levels, so the document itself is shown.
Precise — the source document
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.
What you are building. A 216-state "service cell" that the same no-backprop active-inference engine must keep alive inside a viable set against disturbances it never announces — an open, pre-registered falsification benchmark whose published losses are the credibility, not a hidden failure. A developmental SIMULATION of autopoietic homeostasis, never a living cell and never a person.
This is the second-earned rung (~2 of 11+). It re-reads autopoiesis as homeostatic prediction-error control: a cell stays a cell by predicting the consequences of its own acts and correcting drift before the viability edge is crossed. Same engine as L0, one scale up.
Ingredients
Pantry engines this recipe calls by name:
- The Cell Lab (precision labs): the open pre-registered falsification benchmark — a
hidden 216-state service cell (factor sizes
[4,3,3,3,2], 10 actions), observation-only controllers,RecoveryScore, a bootstrap 95% CI gate, 8 honesty fences + aframing_guardbuild test, plusCLAIMS.mdandFALSIFICATION.md. - The JAX POMDP + EFE + Dirichlet engine (
core.py, uni-mind): supplies the cell's discrete POMDP loop (active_inference_step, exact posterior, EFE/policy selection; conjugate-Dirichletcounts + lr*sufficient_stat, AST no-backprop guard). - Method constitution: M2 (bars-before-build, held-once), M7 (contains-baseline + load-bearing discriminator), M15 (honesty-fence-as-the-pitch), M9 (class authority).
- The inline-engine + canonical-TS + parity-test triad: the vanilla-JS engine inside
cell-lab.html, mirrored byservice_cell.tsinapi/_lib/worlds/, pinned by a*_parity.tstest so the page cannot lie about its math. Determinism via a Mulberry32 seeded PRNG + a committedcell-bench-cache.json.
Method
- Build the hidden world. Stand up the 216-state service cell and the disturbance
families (e.g.
database_flaky,memory_leak,cpu_noisy_neighbor) — the cell never announces which family is acting. Define the viable set; falling outside it is the thing recovery must prevent. - Make every controller observation-only. UNI active inference, a rule-based SRE heuristic, a random control, and a small neural-net (MLP) baseline all see only observations — no privileged read of the hidden 216-state truth. This is the M7 tuned- baseline requirement: UNI must beat strong controls, not strawmen.
- Pre-register the gate (M2). Register
RecoveryScoreand the significance rule: a bootstrap 95% CI on the median paired difference that must exclude 0 — seeded PRNG, committed result cache, never one seed. Seal before scoring. The verdict is the CI bound, never the point estimate. - Wire honesty as a test. Install the 8 honesty fences + the
cell_framing_guard.tstest that fails the build if the page's framing copy, the Zenodo DOI caveat, accessibility, or the "this is our own schema, NOT a reproduction of Rao's verified method" labeling regresses. A claim linter over status comments auto-downgrades any overclaim (the general M8 discipline: a status linter is meant to catch an inflated "PROVEN" and force it to the held class — a method note, not a recorded Cell-Lab event). - Run the tournament. UNI vs rule-based, neural, and random across all failure modes.
Pin the page engine to
service_cell.tswith the parity test. - Put the losses at the top of the live leaderboard (M15). The board surfaces UNI's defeats first; disconfirmations are the deliverable, not theatre.
Gate (exact ledger figures — L1.1)
UNI tops the leaderboard on most modes, with the win measured the only honest way:
RecoveryScore's bootstrap 95% CI on the median paired difference separates from the
control where a win is claimed (CI excludes 0), the framing_guard passes (no overclaim
is emitted), and the bootstrap CI is correctly computed. Significance = a bootstrap 95% CI
excluding 0, never a point estimate. (The ledger records the outcome at this grain only —
"UNI tops the leaderboard on most modes"; no per-control win-counts are claimed here.)
Evidence class: C (dev-gate / held-out eval).
Falsifier (operable)
The L1 PASS falls if, on the pre-registered benchmark, any one of these holds:
RecoveryScore's CI fails to separate from the controls on a mode where a win is claimed; OR- a fence / the
framing_guardtest fails (an overclaim is emitted); OR - the bootstrap CI is shown to be miscomputed.
Companion falsifier for the recorded negative (L1.2): if UNI's RecoveryScore CI later
separates above baseline on the three lost modes, the recorded loss did not replicate.
Recorded NEGATIVE (first-class, inline — L1.2)
UNI honestly LOSES on three modes, recorded in FALSIFICATION.md and shown at the
top of the live leaderboard:
| Failure mode | Winner | UNI score |
|---|---|---|
database_flaky |
rule-based SRE (0.803) | 0.759 |
memory_leak |
neural (0.810) | 0.740 |
cpu_noisy_neighbor |
neural (0.824) | 0.749 — UNI-vs-random not even significant here |
Class C. These are not bugs to fix before publication; they are the published content.
On cpu_noisy_neighbor UNI does not even clear the random control significantly — and that
fact is printed first, not buried.
HONEST FENCE — proven (Class C, with honest losses)
A held, pre-registered, bootstrap-CI-gated benchmark exists and is signed PASS on most modes, with its falsifier still live and its three defeats published at the top of the leaderboard. Not "sovereign" — "good but not sovereign." Active inference is one capable controller among several, beaten cleanly on three named modes by a tuned heuristic and a neural baseline; those losses are top-of-leaderboard content.
Not claimed at L1: not a living cell, not "created life", not awareness, not comprehension, not a general-purpose controller, not AGI. This is the cellular / zygote end of the developmental ladder only. The Cell Lab models autopoiesis as homeostatic prediction-error control in a toy world, never the real world; the Zenodo preprint (Polzin et al. 2026, DOI 10.5281/zenodo.19785799, MIT) behind the math stays fenced as an unrefereed mathematical foundation (Layer-1 AI-executable audit complete; Layer-2 human expert review PENDING). Honest program position: ~2 of 11+ developmental rungs earned. Where this recipe and the ledger disagree, the ledger wins.
sha256 b76f33d20dc41624 — of the original file, so what was ingested stays checkable.
Plain — written for this website, not the source document
This recipe is one scale up from a first cell division. It builds a small simulated service cell that the same engine has to keep inside a viable range while disturbances it is never told about push it out. The page calls it a simulation of self-maintenance, never a living cell and never a person.
The one thing this page says is that the losses are the product. The benchmark is open and registered before the run, and several rival controllers are properly tuned rather than strawmen. Where this engine is beaten, the defeat is shown at the top of the live board rather than tucked into an appendix.
It is careful about what a win means. A win counts only when a bootstrapped interval on the paired difference separates from the control, never on a single best number and never from a single seed. A test in the build fails if the page's own framing drifts upward into an overclaim. Three named failure modes are recorded where rival controllers win, and on one of them the page notes this engine does not even clearly beat a random control. The verdict offered is good, but not sovereign.
Plain · written 2026-08-01 by claude-opus-5 · not yet checked by a person · about the document whose sha256 is b76f33d20dc41624
Clear — written for this website, not the source document
This chapter re-reads the idea of a cell keeping itself a cell as a control problem: predict the consequences of your own actions and correct drift before the edge of viability is crossed. It is the same engine as the previous rung, one scale up, and the page marks it as a simulation of that process rather than as a living cell.
What is actually built is an open falsification benchmark. A hidden service world is stood up along with families of disturbance, and the cell is never told which family is acting. Every controller in the contest — this engine, a rule-based operations heuristic, a small neural network, and a random control — sees only observations, with no privileged read of the hidden truth. That constraint is deliberate: the requirement is to beat strong controls, not weak ones.
The gate is registered before the build. A recovery score is defined, and significance is fixed in advance as a bootstrapped interval on the median paired difference that must exclude no-difference, computed from a seeded generator and a committed cache of results rather than from one run. The verdict is that interval, never the point estimate. Honesty is wired in as a test rather than as a promise. A set of standing limits is backed by a guard test, and that test fails the build if the page's framing copy, its citation caveat, its accessibility, or its labelling of whose method this is regresses. The engine on the page is pinned to the project's reference implementation by a parity test, so the demonstration cannot drift away from the mathematics it claims.
The pass condition is recorded at a deliberately coarse grain: this engine tops the leaderboard on most modes, with each claimed win backed by an interval that separates from its control, the framing guard passing, and the interval correctly computed. No per-control win counts are claimed. The falsifier, the result that would sink the claim, is the mirror: an interval that fails to separate where a win is claimed, a failing check, or a mis-computed interval.
Then comes the part the chapter is proudest of. The engine honestly loses on three named failure modes, each to a different rival: one to the rule-based heuristic and two to the neural baseline. Those losses are published at the top of the live leaderboard rather than fixed before publication. On one of the three, the page records that this engine does not even clear the random control significantly, and says that fact is printed first, not buried. A companion falsifier is attached to the losses themselves: if a later run shows the score separating above baseline on those modes, then the recorded loss did not replicate.
The closing verdict reads good but not sovereign. This approach is one capable controller among several, cleanly beaten on named modes by tuned alternatives. Not claimed: a living cell, created life, awareness, comprehension, a general-purpose controller, or general intelligence. The underlying preprint stays labelled as an unrefereed mathematical foundation with expert review pending.
Clear · written 2026-08-01 by claude-opus-5 · not yet checked by a person · about the document whose sha256 is b76f33d20dc41624