Overview · Written article
Quick start
Fifteen minutes from nothing to a running active-inference engine you can watch think. No accounts, no GPU, no network after the first fetch.
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.
These 13 pages are the only ones on this site written for this site. Everything else you can read here is a real file from a working repository, republished as it stands. These were written by hand for someone arriving with no context: an entry point, one article for each major part of the estate, and a set of practical guides for installing, running and maintaining things.
They carry one unusual discipline. Every citation in them points at a real file at a named commit, and the build resolves it there. If the file has moved, or a quoted range has run off the end of it, the build fails. It will not publish a reference that no longer lands. The wording of an article can drift out of date; what it points at cannot silently do so.
Start with "Start here". It is short, and it explains the one idea the rest of the estate is arranged around. After that, read whichever part you care about, or go to the quick start if you would rather run something than read about it.
What they are not: authoritative. An article is prose about documents, and the documents are the record. Where the two disagree, the document is right and the article is the thing to fix.
Your browser cannot switch reading levels, so the document itself is shown.
Precise — the source document
This is the article as written. Every citation and quoted block in it is resolved against the real file at the real commit when the site is built.
RUNNABLE BY YOU. Everything on this page runs on an ordinary laptop — Linux, macOS or Windows. No GPU, no accounts, no API keys, no paid software. The core has zero package dependencies, so after you have Elixir installed it does not even need the network.
This is the shortest path from nothing to something you can watch. It deliberately skips the colony, the broadcast and the operator plane, because all three need infrastructure and none of them is the interesting part first.
What you will have at the end
An active-inference engine running on your machine, a benchmark table of its real behaviour, and a recorded run you can independently verify — including the verification failing if you tamper with the recording.
1. Install one thing
Elixir 1.18 or later, on OTP 27. That is the only prerequisite for this page.
elixir --version
If that prints a version, you are ready. If not, install Elixir from your package manager or from
elixir-lang.org; the full prerequisite list for everything else is in the
install guide.
2. Compile and test
mix compile
mix test
The compile fetches nothing. That is a design decision rather than an accident, and the reason is stated where it is enforced:
# The pure simulation core has ZERO dependencies so that `mix test` is fully
# offline and deterministic (no hex fetch required). Property-style tests are
# implemented as seeded sampling loops in test/support/sp_prop.ex.
# The live Jido runtime adapter (SP.Runtime) is documented in
# docs/runtime/jido_alignment.md and depends on the vendored jido path.
defp deps do
[]
endZero dependencies means mix test is fully offline and deterministic. It also means nobody can break
your build by deleting a package.
3. Watch it think
mix run scripts/demo.exs
This is a live demonstration of the core guarantees rather than a toy. Then, for the numbers:
mix run scripts/benchmark.exs
That prints the operator baseline table — the real timings and behaviour of the engine on your machine, not a recorded figure from someone else's.
4. Record a run, then verify it
This is the pair that makes the rest of the estate make sense.
mix run scripts/record_run.exs 314 morphology_seeking 120
That writes a run file: a seeded agent, 120 steps, every observation and action recorded. Now check it:
mix sp.verify runs/seed314-morphology_seeking.jsonl
The verifier re-derives the run from the seed and compares. Now do the interesting thing: open the run file, change one number in the middle, and verify it again. It must fail. A verifier that has never been shown to fail is not a verifier, and that principle runs through everything here — the gates in this estate are mutation-tested by deliberately introducing a defect and requiring the check to go red.
5. See the golden artifact hold the line
mix run scripts/gen_golden.exs
Then ask git whether anything moved:
git diff --exit-code config/golden/
Silence means the engine's behaviour is byte-for-byte what it was. This exact pair runs in continuous integration: regenerate, then diff. If the engine's output drifts for any reason — an intended improvement or an accident — the build fails and somebody has to say which it was.
6. Look at the evidence machinery
mix run scripts/evidence.exs
mix sp.uni.prove
mix sp.brain.verify
The first regenerates the validation evidence numbers. The second and third are proof tasks over the agent and its inference core.
Where to go next
You now have the engine. The three directions out of here:
- Understand what you just ran → The active-inference brain and The colony. There is no reward signal anywhere in what you ran, and that is worth understanding before you read the code.
- Run more of it → Install guide for the full prerequisite list, then Run it for every entry point in the estate with its real command.
- Try to break it → The falsification invitation. It is a standing request, not a formality.
What this page does not claim
Running the demo tells you the engine works. It tells you nothing about biological parity, general intelligence, or human parity, and the estate's own contract says so in those words. The colony, the Producer and the broadcast are not covered here because they need a Minecraft server, a licensed game client and — for the broadcast — hardware and accounts. See what a stranger can and cannot run for the honest boundary.
Plain — written for this website, not the source document
This is the shortest path from nothing on your machine to something you can watch running. It needs one piece of software, no accounts, no graphics card, and no network after the first install. It skips the colony, the broadcast and the operator surfaces on purpose, because all three need infrastructure and none of them is the interesting part first.
What you have at the end is the reasoning engine running locally, a table of its real behaviour on your machine rather than a figure from someone else's, and a recorded run you can check independently. The page is firm that the demonstration is a real exercise of what the engine promises, not a toy.
The step the page puts most weight on is the awkward one. After verifying a recorded run, open the file, change one number in the middle, and verify it again. It has to fail. A verifier that has never been shown to fail is not a verifier.
The page closes by saying what running the demonstration does not tell you: nothing about biological parity, general intelligence or human parity.
Plain · written 2026-08-01 by claude-opus-5 · not yet checked by a person · about the document whose sha256 is 3e2be1538b3808a1
Clear — written for this website, not the source document
This is the on-ramp page: from an empty machine to a running inference engine you can watch think. It states its requirements honestly at the top: an ordinary laptop, no graphics card, no accounts, no keys, no paid software. It also notes that the core has no package dependencies at all, so once the language is installed it does not even need the network.
It deliberately skips the colony, the broadcast and the operator plane, on the grounds that all three need infrastructure and none of them is the interesting part first.
The sequence is short. Install one language runtime at the stated version. Compile, which fetches nothing, and run the tests, which are therefore fully offline and deterministic — and, the page notes, nobody can break your build by deleting a package. Run a demonstration described as a live exercise of the core guarantees rather than a toy, then a benchmark that prints the real timings and behaviour of the engine on your own machine.
Then the part the page cares about most, which it calls the pair that makes the rest of the estate make sense. Record a run — a seeded agent, a fixed number of steps, every observation and action written down — then verify it, which re-derives the run from the seed and compares. Then do the interesting thing: open the file, change one number in the middle, verify again, and watch it fail. The reasoning is stated as a principle running through everything here, that a verifier never shown to fail is not a verifier, and that the estate's checks are tested by deliberately introducing a defect and requiring them to go red.
Next it has you regenerate a recorded reference artifact and ask the version-control system whether anything moved. Silence means the engine's behaviour is byte-for-byte what it was. The same pair runs automatically, because an intended improvement and an accident produce the same difference and somebody has to say which it was.
Finally it points at the evidence machinery and gives three directions onward: understand what you just ran, run more of it, or try to break it — the last described as a standing request rather than a formality.
It ends by bounding the claim. Running the demonstration tells you the engine works. It tells you nothing about biological parity, general intelligence or human parity, and the parts needing a game server, a licensed client, hardware and accounts are not covered here.
Clear · written 2026-08-01 by claude-opus-5 · not yet checked by a person · about the document whose sha256 is 3e2be1538b3808a1