Wiki · The Colony & the Method
Blanket Evidence Log & Independent Verification
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.
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.
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.
The evidence log is the falsifiable record of everything that crossed (and did not cross) the Markov blanket each tick. It is produced by the simulator and can be re-verified by any third party with nothing but this repo and the run's seed — the verdict is re-derived, never trusted from an engine-stamped flag.
Producing a log
mix run scripts/record_run.exs 314 morphology_seeking 250
# -> runs/seed314-morphology_seeking.jsonl (one JSON object per recorded tick)
# -> runs/seed314-morphology_seeking.meta.json (provenance + channel reveal tables)
In code: SP.Sim.new(..., record_blanket?: true) then SP.Sim.Recorder.write(sim, base).
Use record_every: N and max_frames: M to bound long runs. Recording is OFF by
default and is a pure read of already-computed state, so it never affects agent
behaviour or determinism (proven by SP.Sim.BlanketTest).
Re-verifying (headless, falsifiable)
mix sp.verify runs/seed314-morphology_seeking.jsonl
# VERIFIED: 46 frames, 0 blanket violations. (exit 0)
Tamper with any observation value or signal and it fails, naming the frame:
VIOLATION: 1/46 frames leaked. First: {"frame":20,"reasons":["encode_equivalence"],"tick":21}
(exit 1)
SP.Sim.Verifier.check_log/1 rebuilds the channel map from the recorded seed (the
public algorithm in SP.Interface.channel_map/2), then runs four checks per frame:
- Structural —
Audit.audit_observation(obs) == :ok(integer channels in range, finite numbers only). - Token scan —
Audit.scan(obs) == [](no semantic tokens). - Morphology provenance — every observed channel maps to a sensor whose organ
was present at sensing time (
afferent.decision_organs). No channel may exist that the recorded morphology could not have produced. - Encode-equivalence —
encode_observation(cm, recorded_signals) == obsexactly. The observation is precisely the channelisation of the recorded signals — no hidden side-channel.
Frame schema (one JSON object per tick)
{
"tick": 21,
"world": { "seed", "tick", "region_count", "seam_threshold",
"adjacency", "seams",
"regions": [ { "id","w","h","law",
"seam_readiness","seam_ready",
"layers": { "nutrient":{w,h,cells[]}, "temperature":{…},
"solvent":{…}, "toxin":{…}, // L0
"cavity":{…}, "strain":{…}, // L2
"bands":[{…},{…},{…}] }, // L3
"materials": { "<cell>": { "<material>": amt } }, // L1
"conduits": [[i,j]], // L2 transport
"infrastructure": { "<cell>": [{kind,integrity}] },
"ecology": [{cell,kind,energy}] } ] }, // L4 via seams
"body": { "location","energy","hydration","temperature","integrity",
"growth_budget","stage","alive","inventory","organs","parts" },
"genome": { "lineage","growth_plan","maturation_rate","thrift",… },
"afferent": { // world -> agent (the blanket, inbound)
"signals":[ {"type","source","time","data"} ],
"observation": { "<channel>": float }, // the ONLY world->agent datum
"derivation": [ {channel,source,key,organ,affine,encoded} ],
"decision_organs": ["interoception","chemotactile",…]
},
"efferent": { // agent -> world (the blanket, outbound)
"directives":[ {kind,channel,params} ],
"decoded":[ {channel,action,params,decoded,gated,applied} ]
},
"blanket": { // engine CLAIM — re-derived, never trusted
"audit":"ok", "scan_leaks":[],
"channels_explained":true,
"context_redacted":false // true under faithful mode
}
}
The derivation table and the meta sidecar's reveal maps expose channel↔semantic
meaning. That is correct for the observer/verifier side and is produced only
after decide/3 has already run; it is never placed on the agent path. Faithful
mode (faithful?: true) additionally removes the channel map from the agent's
decision context, so the opaque observation is provably the sole world-derived
input.
What the log proves (and how it could be falsified)
- No hidden state reaches the agent — checks 1–2 reject any non-opaque value; check 4 proves the observation is exactly the recorded signals channelised.
- No impossible perception — check 3 rejects any channel the morphology could not have produced.
- The agent is outside the world — under faithful mode,
context_redactedasserts the observation was the only world-derived input.
If any of these were false, the corresponding check fails and mix sp.verify
exits non-zero. The negative tests in SP.Sim.BlanketTest inject each leak class
and confirm the checks bite.
sha256 78d0b9193f5f58b3 — of the original file, so what was ingested stays checkable.
Plain — written for this website, not the source document
This page describes a recorded log of everything that crossed the boundary around the agent on each tick, and the separate command that re-derives the verdict from it.
The point is independence. The verdict is re-derived from the recorded bytes rather than taken from a flag the engine set. A third party needs only this repository and the run's seed.
Recording is off by default, is a pure read of state already computed, and does not affect behaviour or repeatability. A command produces a log; another command checks it and exits non-zero if anything leaked, naming the first frame that failed.
Four checks run per frame. The observation must be structurally clean, and it must contain no meaningful tokens. Every channel in it must be one the body's organs at that moment could have produced, and re-encoding the recorded signals must give back exactly the observation.
The frame layout is printed in full, and a closing section says what each check would catch.
Plain · written 2026-08-01 by claude-opus-5 · not yet checked by a person · about the document whose sha256 is 78d0b9193f5f58b3
Clear — written for this website, not the source document
This document describes the evidence log: a record of everything that crossed the boundary around the agent on each tick, together with the independent means of checking it.
The framing sentence is the important one. The log is described as falsifiable because it can be re-checked by any third party with nothing but the repository and the run's seed, and because the verdict is re-derived rather than trusted from a flag the engine stamped.
Producing a log is one command, which writes a file with one record per recorded tick plus a sidecar carrying provenance. Options bound long runs. The page is explicit that recording is off by default, and is a pure read of state that has already been computed. So it does not change the agent's behaviour or the repeatability of a run, and it names the test behind that.
Re-checking is another command. The page shows the clean result and then shows what happens after tampering with a single observation value: the run fails, names the first frame, gives the reason, and exits non-zero.
The verifier rebuilds the mapping between channels and features from the recorded seed, using the same public algorithm, and then runs four checks on every frame. The first requires the observation to be structurally clean, with channels in range and only finite numbers. The second scans for meaningful tokens. The third checks provenance against morphology: every observed channel must map to a sense whose organ was present at the moment of sensing, so no channel may exist that the recorded body could not have produced. The fourth requires that re-encoding the recorded signals reproduces the observation exactly, which closes off any hidden side channel.
The frame layout is then printed in full, with annotations. It carries the tick, a snapshot of the world down to per-layer grids and infrastructure, the body, and the genome. Then the inbound side with its signals, the observation, a derivation table and the organs in play, and the outbound side with instructions and decoded actions. Last comes the engine's own claim about the boundary, labelled in the document as a claim that is re-derived and never trusted.
A paragraph handles a subtlety honestly. The derivation table and the sidecar do expose the mapping between channels and their meanings, which is correct for the observer and the verifier. They are produced only after the decision has already been made, so they never sit on the agent's path. A stricter mode additionally removes the mapping from the agent's decision context so the opaque observation can be shown to be the sole world-derived input.
The closing section states what the log would catch, and how the whole thing could be broken. Each check corresponds to a class of failure, the checking command exits non-zero when one fires, and negative tests inject each class to show the checks bite.
Clear · written 2026-08-01 by claude-opus-5 · not yet checked by a person · about the document whose sha256 is 78d0b9193f5f58b3