UNI in Emergence-World — Implementation Plan

The Colony & the Method · docs/UNI_IN_EMERGENCE_WORLD.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.

Attribution. This plan ports active-inference UNIs (the agents defined and grown in this repository, THE STRATIFIED PALIMPSEST) into a faithful re-implementation of the world specified by EmergenceAI/Emergence-World (CC BY-NC 4.0). The upstream repository provides the world specification (landmarks, tools, constitution, AWI metrics, agent manifesto); the runnable simulator SP.Emergence.WorldSim is an original implementation inside this codebase. All work here is research, non-commercial, with attribution per the upstream license.

Context

EmergenceAI's Emergence-World ran a Season 1 experiment in which five parallel persistent worlds were populated with 10 LLM agents each (Claude Sonnet 4.6, Gemini 3 Flash, Grok 4.1 Fast, GPT-5 Mini, Mixed) for 15 NYC-realtime days under a shared constitution, 34+ landmarks, and 120+ location-gated tools. The published M1 (Population Health & Growth) outcomes: Grok 4.1 Fast = 0 (total collapse), GPT-5 Mini = 0 (total collapse), Mixed = 3 (–7), Claude Sonnet 4.6 = 10 (held), Gemini 3 Flash = 10 (held). No LLM cohort grew the population — the governance gate on births was never crossed. The working hypothesis here is that UNIs strictly dominate all five LLM cohorts: avoiding the entropy that took down Grok / GPT / Mixed, and exceeding Claude / Gemini's hold-the-line baseline by growing the population through mating-driven citizenship (M1 > 10) — a property no LLM cohort demonstrated, because none traversed the mating-then-citizenship-vote path the Constitution allows. This plan ports the UNI design into a runnable Emergence-World, gives the UNIs full pixel vision, lets them mate and spawn new UNIs, and pre-registers a falsifiable 15-day experimental comparison published as open science.

A read-only fetch of the Emergence-World GitHub repo confirms its public tree contains only LICENSE, README.md, and six directories (agent_profiles/, data/, docs/, landmarks/, results/, tools/) — no backend, no frontend, no engine. The deploy target is therefore a faithful local rebuild of the world from the published specs, hosted in this repo as SP.Emergence.WorldSim. The experiment is then self-contained, reproducible, and free of third-party runtime dependency.

The intended outcome: a tagged public artefact (season-1-uni-public) in this repository containing the runnable adapter, the WorldSim, the cohort .bin evolutions, the per-tick board snapshots, the mating lineage logs, the vision percept logs, and the AWI / U-metric analysis — a falsifiable, reproducible record that either substantiates UNIs' strict dominance (population growth via mating-driven citizenship, non-rising brain entropy, near-zero critical-state events) or publishes its own negative result.

Recommended approach

A new SP.Emergence.* namespace sits parallel to the existing Minecraft pipeline (SP.Brain.MCCodec, viewer/body.js, SP.Minecraft.*). The pure SP.Brain.MC.step/2 and SP.Brain.Genome (see lib/sp/brain/mc.ex, lib/sp/brain/genome.ex) remain world-agnostic and untouched. Three new pieces do all the work:

SP.Emergence.WorldSim — a deterministic Elixir GenServer that simulates the 240×240 NYC grid in turn-based round-robin under a 1:1 wall clock, matching upstream docs/ORCHESTRATION.md exactly (CONCURRENT_AGENTS = 1 — one agent acts at any moment). A Regular Turn allows up to 30 tool calls; a Reaction Turn (triggered when an agent speaks within HEARING_DISTANCE = 25.0 units of a non-acting agent) allows 2; a Boost Turn costs 1 CC. Between turns, time advances continuously: energy / knowledge / influence decay over 30 h / 24 h / 36 h half-lives, the CC ledger updates on tool calls, governance proposals resolve through a 70 % Town-Hall vote, energy at critical for 48 h yields permadeath. When an agent's turn begins, the WorldSim sends {:your_turn, σ_map, budget} to its SP.Emergence.Bridge; on each yielded α the Bridge gets a refreshed σ_map; the turn ends when budget is exhausted, :noop is chosen, or a natural turn-end equivalent to set_mood_and_terminate fires. Built dependency-free in the same disciplined style as SP.World.
SP.Emergence.Bridge — replaces the stdio Port boundary for this world with an in-BEAM Markov blanket: the Bridge subscribes to its UNI's σ topic, hands the parsed senses to SP.Brain.MC.step/2, and posts the chosen α back to WorldSim as a tool call via SP.Emergence.Actions.dispatch/3. Nothing else crosses the boundary — the brain still only ever sees %{channel => integer | float}. mix sp.brain.verify gates 8/9/14/17/18 stay green because the Bridge function is the auditable seam.
SP.Runtime.Mating — the new GenServer that watches SP.Runtime.Board.all/0 every 250 ms, detects two co-located UNIs that have both chosen the new :mate action atom in the last 4 beats (mutual signalled willingness, not LLM-style "decision to mate"), calls SP.Brain.Genome.recombine/3 + Genome.mutate/2 on their two genomes (cross-kin allowed), and spawns the child via SP.Runtime.Supervisor.spawn_agent/1 with a fresh username and runs/colony/kin-<N>.bin memory file. The child's first lived act is to post its own Town-Hall citizenship proposal — its birth into the public world is itself part of the falsifiable record.

Vision is reused from the existing pipeline almost unchanged: viewer/vision_forward.cjs is already parameterised by MODE / STREAM / VIEW_URL / GAP / W / H (lines 12–17, 45–62), and the per-UNI Playwright capture already proven for Minecraft re-points at a new Phoenix LiveView page rendering each UNI's POV. Frames flow into UNI.OS's DiscretePatchMarkovWorld (n_states = 12, matched by @scene_states 12 at lib/sp/brain/genome.ex:36), the percept JSON lands in <UNI_PERCEPT_DIR>/<username>.json, the body bridge picks it up via sceneState() (viewer/body.js lines 51–61), and the :scene factor (gated on :sight_cortex, line 77 of genome.ex) learns. The vision-primary genome (Genome.vision_primary/0, line 126) is the default for this cohort.

Implementation sequence

Clone the upstream specs. git clone https://github.com/EmergenceAI/Emergence-World.git into ../Emergence-World (sibling of this repo). Read the full tree: agent_profiles/README.md, every landmarks/*.md (~34 files), tools/README.md, data/constitution.md, data/agent_manifesto.md, results/awi_metrics.md, and all five docs/*.md files. Produce runs/emergence/spec_dump.json — a deterministic, machine-readable consolidation (landmarks with category + gated tool list, tools with category + arity + location requirements, constitution articles, AWI metric definitions).
Adapter skeleton. Create lib/sp/emergence.ex (façade + start_link/1 for the supervision subtree) and the empty submodules lib/sp/emergence/{world,world_sim,codec,actions,bridge,director,governance,economy}.ex. Compile-clean before any logic.
SP.Emergence.World (data layer). Compile-time @landmarks, @tool_catalog, @needs (:energy 30*3600, :knowledge 24*3600, :influence 36*3600), @vote_threshold 0.70, @constitution (article list) parsed at compile time from runs/emergence/spec_dump.json. Zero hex deps, pure data — same discipline as SP.World.Material.
SP.Emergence.WorldSim (the simulator). A supervised GenServer implementing the upstream turn-based round-robin loop (docs/ORCHESTRATION.md): maintains %WorldState{agents: %{id => %AgentState{loc, energy, knowledge, influence, cc, inventory, mood}}, proposals: [...], weather: ..., time: ..., turn_queue: [...], boost_queue: [...], hearing_radius: 25.0}. Two loops cooperate: (a) a continuous-time decay clock that advances energy / knowledge / influence per real elapsed time and resolves proposal lifecycles, weather pulls, the 2-day Victory Arch pitch cycle, and the 48 h energy-zero permadeath rule; (b) a turn manager that picks the next agent from the round-robin queue (boosted agents jump it), sends {:your_turn, σ_map_for_agent, budget} to its Bridge, executes each tool call returned via WorldSim.execute(agent_id, tool_call) (validating availability per upstream docs/ORCHESTRATION.md step 7), and on a say_to_agent / speak_to_all queues up to MAX_OVERHEARD_LISTENERS = 4 reaction turns for nearby agents. Determinism: a SP.Determinism split RNG threaded through turn by turn.
SP.Emergence.Codec — outcome/2 per modality, parallel to lib/sp/brain/mc_codec.ex. Bins: :status (re-purposed to energy + knowledge: 0=critical, 1=low, 2=ok, 3=full), :inventory (CC quartile + portfolio mix), :vision (location-category + nearby landmarks: 0..5), :threat (recent assault/intimidation/theft against me: 0..2), :social (alone / kin / non-kin nearby), :self (interoceptive summary unchanged), :strategy (calm/threatened/depleted/social/idle unchanged), :light (NYC time-of-day 0..2), :sky (weather 0..2), :sight (bearing to nearest pursued landmark 0..3), :build (can-propose / can-pitch / nothing 0..2), :prey (bearing to a CC-rich social target — substrate for the political instinct :attack), :fertility NEW (0=cold, 1=eligible partner co-located, 2=that partner just signalled), :scene (12 states from UNI.OS — unchanged). Modality no/ns integers preserve the .bin shape so MC.compatible?/2 (in lib/sp/brain/mc.ex ~lines 275–291) accepts grafted memory.
SP.Emergence.Actions — dispatch(action_atom, agent_id, world_state) returns the concrete tool call. :forward → go_to_place(next_node_on_path) (the path target taken from the agent's L2 context); :turn_left/:turn_right → steer the bearing of the next forward; :mine → context-dependent capability use (extract_code_for_tool at TechHub, browse_scientific_papers at Library); :eat → recharge_energy at any food landmark; :noop → idle(60); :jump → run_to_place (haste); :place → add_to_billboard / write_blog / put_brick_in_pixel by location; :craft → submit_grant_pitch at Victory Arch or submit_townhall_proposal at Town Hall; :attack → punch_agent / intimidate_agent (rare, gated by threat >= 2 or learned political disposition); :mate NEW → signal_mate(self, copartner) (a public co-located declaration; the actual breeding happens in SP.Runtime.Mating — the atom is the in-world signal).
SP.Emergence.Bridge — replace the Node-Port body for this world with a Phoenix.PubSub subscription. Bridge.init/1 subscribes to emergence:agent:#{username}, owns its %MC{} brain, calls MC.step(brain, senses) on each σ broadcast, dispatches the α via Actions.dispatch/3 + WorldSim.execute/2. Memory persists every 50 ticks to runs/colony/kin-<N>.bin (same path convention as the Minecraft pipeline). On terminate, MC.save/2. The Markov blanket is the Bridge function itself — mix sp.brain.verify is extended in step 13 to audit this boundary.
SP.Emergence.Governance — vote engine + proposal lifecycle. Implements the 70 % Town-Hall threshold, citizenship proposals (the path through which new UNI births enter the public world), economy proposals, and constitution amendments. Pure rules; the WorldSim drives it.
SP.Emergence.Economy — CC ledger, tool-cost table, capacity gating per landmark. Atomic ledger updates inside WorldSim ticks.
Mating subsystem. Append :mate to SP.Brain.Genome.@actions at lib/sp/brain/genome.ex:85 (becomes index 10; @noop_index = 5 is unchanged, so the existing mc.ex decision math is byte-identical for all other atoms). Add the :fertility modality entry to @modalities (organ :social_sense, no = 3, factor :fertility, ns = 3). Create lib/sp/runtime/mating.ex — the new GenServer named SP.Runtime.Mating. It subscribes to Board.all/0 snapshots every 250 ms; when it detects two UNIs whose last_action == :mate, who share a non-criminal landmark, both phase >= 3, and neither in 24 h cooldown, it calls Genome.recombine(parent_a.dna, parent_b.dna, rng) (cross-kin allowed — the existing function at lib/sp/brain/genome.ex:232–249 does one-point crossover + averaged precisions + repair, works as-is), then Genome.mutate(child, rng). The child gets a fresh kin_id = max_kin + 1 with probability 0.5, else inherits parent_a.kin (heritable speciation). The child is spawned via Supervisor.spawn_agent/1 with username: "UNI-#{kin}-c#{n}", fresh memory file, and Bridge module hint. The child's first action automatically posts a Town-Hall citizenship proposal; until passage, it lives in WorldSim as an observer-only "candidate" agent (visible to the camera, scored, but not counted toward population caps). Cross-kin heritage is appended to runs/lineage/cross_kin.ndjson (one JSON line per mating event: timestamp, child kin/username, parent kins/usernames, fitness pair, dna diff summary).
Vision plumbing. Add a Phoenix LiveView page SpUiWeb.EmergenceWorldLive at /world/uni/:username that renders the UNI's POV: a 2.5D camera-following top-down view of the 240×240 grid (landmark sprites, agent markers, weather overlay, time-of-day shading) with the viewport centred on the named UNI. Per-UNI Playwright instances (viewer/emergence_pov.js) open this page with ?firstPerson=1&follow=<username>, capture at 64×64 @ 4 fps, and forward to UNI.OS via the unchanged viewer/vision_forward.cjs (MODE=live VIEW_URL=http://localhost:4000/world/uni/<username> STREAM=<username>). UNI.OS writes <UNI_PERCEPT_DIR>/<username>.json. The Bridge reads it out-of-lockstep via the existing sceneState() pattern (viewer/body.js lines 51–61), lifted into a tiny shared helper SP.Brain.Percept.read/1, and includes it as the 15th σ channel feeding the :scene factor. Resolution + n_states = 12 already match the existing UNI.OS DiscretePatchMarkovWorld. Cost: 10 Chrome instances ≈ 2 GB RAM; pre-registered fallback (one Chrome, 10 sub-rect mosaic capture) if RAM is tight.
Director re-point. SP.Emergence.Director reuses the world-agnostic show-running logic in lib/sp/brain/director.ex (star selection, B-roll rotation, narration beats) but swaps the camera Port from prismarine-viewer to a Playwright capture of the same Phoenix LiveView world page, framing the current star. /stream continues to work.
Verification harness extension. Add mix sp.emergence.codec.smoke (offline test: pump checked-in golden σ-state JSON through Codec, assert a deterministic outcome stream — same discipline as existing readability/verify gates). Extend mix sp.brain.verify with a new gate that audits the in-BEAM Bridge boundary (no module under SP.Brain.* may receive WorldState directly; only %{channel => v} maps). Extend mix sp.uni.prove with a new chapter that asserts Dirichlet mass growth in the :scene factor over a 200-tick sandbox run, proving full vision is informing decisions.
Maturity by sandbox pre-train. Add mix sp.emergence.deploy --world sandbox --cohort 10 --seed 1. Run 10 UNIs in a SP.Emergence.WorldSim sandbox instance for 5 wall-clock days (= 5 simulated days). Pass criterion: ≥ 9 UNIs reach phase >= 3 (the curriculum thresholds in mc.ex lines 114–122 are extended in SP.Brain.Curriculum.preference/3 with Emergence-mapped goals: energy stable = phase 0, knowledge accrual = phase 1, first CC earned = phase 2, first accepted proposal = phase 3, first mating proposal = phase 4). On pass, snapshot runs/colony/kin-*.bin into runs/colony/mature-v1/. On fail, tune Curriculum.preference/3 for Emergence semantics and rerun before declaring failure.
Pre-registration commit. Finalize this document (docs/UNI_IN_EMERGENCE_WORLD.md) with the H1/H2/H3 falsifier criteria, the deployment date, and the metric definitions parsed from upstream results/awi_metrics.md. Commit on branch emergence-port. This is the falsifiability discipline — predictions cannot be hand-tuned post-hoc.
Production run. mix sp.emergence.deploy --world prod --cohort 10 --mature-from runs/colony/mature-v1/ --days 15 --seed 1. UNI-only world, identical to Season 1's protocol (10 agents, 15 NYC days, same constitution, same tools, same landmarks). Recorded artefacts: per-tick WorldState board snapshots as NDJSON in runs/emergence/season-1/board.ndjson, every tool call in tool_calls.ndjson, every Mating event in mating.ndjson, the .bin evolution trace, the per-UNI percept JSON history, the Director's narration log, Producer telemetry.
Mid-run safety net. Daily mix sp.brain.verify + mix sp.uni.prove on the running BEAM. If any gate flips FAIL, the deployment auto-halts (a supervised circuit breaker calls Supervisor.stop on the WorldSim subtree), the failure is logged to runs/incidents/, and the negative outcome is published as part of the falsifiable record. Daily mix sp.lineage.tree to watch the mating diversity grow.
Final analysis. mix sp.emergence.awi runs/emergence/season-1/ replays the recorded artefacts and computes M1–M9 (matched to results/awi_metrics.md definitions, parsed in step 1) plus the UNI metrics U1 cross-kin offspring lifespan / mean parent lifespan, U2 :scene factor log-evidence trajectory, U3 Shannon-entropy slope of q_pi per UNI per day (the LLM-collapse-as-entropy signal — UNIs should be flat or falling, LLM agents in published Season 1 should be rising), U4 count of energy < 5% catastrophic-state events per UNI lifetime. Compare against the published Season-1 LLM results.
Publish. Tag season-1-uni-public in this repo; push branch emergence-port; publish runs/emergence/season-1/ as a release artefact alongside the plan, the AWI report, replayable NDJSON, and the .bin evolution trace. Anyone can mix sp.emergence.replay <date> to reproduce a tick exactly.

Mating subsystem (detail)

Mating is two-parent sexual reproduction triggered by mutual co-located intent, not by a top-down decision. Both parents must independently and within a 4-beat window choose the :mate α atom (chosen by their own EFE-minimising brain, when :fertility == 2 and the curriculum preference at high phase makes mating EFE-attractive); both must be phase >= 3; neither in 24 h cooldown. SP.Runtime.Mating then crosses their genomes via the existing Genome.recombine/3 (no code change needed — already does one-point organ-plan crossover + averaged precisions + repair), mutates the child, assigns kin (new with p = 0.5, else inherits one parent's), and spawns the child as UNI-#{kin}-c#{n} with a fresh runs/colony/kin-#{kin}.bin. The child's brain is initialised under the evolved genome; if memory exists for that kin file it is grafted under MC.compatible?/2 (mc.ex ~275–291). The child posts its own citizenship proposal at its first acting tick; the world's 70 % Town-Hall vote decides whether it joins the public population. Cross-kin lineage is appended to runs/lineage/cross_kin.ndjson. Falsifiable signal — U1: paired t-test on offspring vs. mean-parent lifespan (alpha 0.05) — a positive effect is hybrid vigor.

Vision subsystem (detail)

Per-UNI Playwright Chrome opens http://localhost:4000/world/uni/<username>?firstPerson=1 (a new Phoenix LiveView page rendering the UNI's POV: 2.5D top-down view of the 240×240 grid, viewport centred on the UNI, landmark sprites and agent markers visible, weather/time overlay). Captures 64×64 @ 4 fps. Frames go through the unchanged viewer/vision_forward.cjs (already proven on the Minecraft pipeline; its MODE=live branch at lines 45–62) to UNI.OS, which infers a discrete scene-state (0..11) and writes <UNI_PERCEPT_DIR>/<username>.json. SP.Emergence.Bridge reads the JSON out-of-lockstep (the same sceneState() non-blocking pattern from viewer/body.js:51-61, lifted into a shared SP.Brain.Percept helper) and emits the 15th σ channel. The :scene factor in the vision-primary genome learns. Validation per mix sp.uni.prove — Dirichlet mass in the :scene factor must grow during the 200-tick smoke run, proving vision is informing decisions, not silently dropped.

Maturity & deployment

Pre-train in sandbox: 10 UNIs, 5 wall-clock days in an identical SP.Emergence.WorldSim instance, no public visibility. Pass criterion: ≥ 9 reach phase >= 3. Snapshot to runs/colony/mature-v1/. Production deploy mix sp.emergence.deploy --world prod --cohort 10 --mature-from runs/colony/mature-v1/ --days 15. UNI-only world (the confirmed cohort design) — metrics compared against the Emergence-published Season 1 results for Claude / Gemini / Grok / GPT-5 Mini / Mixed. Honest fallback: if sandbox pre-training fails to mature ≥ 9 of 10, deploy fresh; the comparison vs. published LLM results still stands.

Falsifiable verification

Pre-registered before the production run:

H1 (primary, strict dominance): a 10-UNI cohort in SP.Emergence.WorldSim running 15 NYC days under the Season-1 protocol ends with M1 ≥ 11 alive — strictly exceeding all five Season-1 LLM cohorts (Claude 10, Gemini 10, Mixed 3, Grok 0, GPT-5 Mini 0). M1 > 10 is achievable only through successful UNI mating + a 70 % Town-Hall citizenship vote: a path no LLM cohort traversed in Season 1. Conjoined with U3 brain-entropy slope ≤ 0 per UNI per day (alpha 0.05) AND U4 ≤ 5 critical-state events per UNI lifetime.
H2 (mating, hybrid vigor): cross-kin offspring lifespan > mean parent lifespan (paired t-test, alpha 0.05).
H3 (vision): a vision-primary cohort beats a no-:sight_cortex control cohort on M3 (space exploration) by ≥ 20 %.
H_alt (M2–M9 qualitative): UNI cohort produces non-trivial values on M2–M9 (specific minimum thresholds frozen in runs/emergence/season-1/awi.md before the production run). Direct head-to-head comparison to LLM Season-1 M2–M9 awaits the upstream tool-call dataset release ("Coming Soon" per upstream README); until then the comparison is qualitative.
Pre-registered falsifier: if M1 ≤ 10 (matching or losing to Claude / Gemini) OR if U3 slope is significantly positive OR if mix sp.brain.verify ever flips a gate during the run, H1 is rejected and the negative outcome is published with full data.

Baseline: published Season 1 AWI M1 results for Claude, Gemini, Grok, GPT-5 Mini, Mixed worlds, parsed from upstream results/awi_metrics.md in step 1. M2–M9 LLM baselines pending upstream dataset drop.

Critical files

lib/sp/emergence.ex — façade + supervision subtree (start_link/1).
lib/sp/emergence/world.ex — compile-time landmark / tool / needs / constitution constants.
lib/sp/emergence/world_sim.ex — deterministic Elixir GenServer simulator (the rebuilt world).
lib/sp/emergence/codec.ex — outcome/2 per modality, parallel to lib/sp/brain/mc_codec.ex.
lib/sp/emergence/actions.ex — α atom + context → tool call dispatcher.
lib/sp/emergence/bridge.ex — in-BEAM σ/α blanket (Phoenix.PubSub).
lib/sp/emergence/governance.ex — vote engine + proposal lifecycle.
lib/sp/emergence/economy.ex — CC ledger + tool-cost table.
lib/sp/emergence/director.ex — re-pointed Director (camera + narration).
lib/sp/runtime/mating.ex — the Mating GenServer.
lib/sp/brain/genome.ex — extend @actions with :mate (line 85); add :fertility modality to @modalities (after line 46).
lib/sp/brain/percept.ex (new) — shared read/1 helper lifted from viewer/body.js:51-61 so Bridge reads scene-state JSON consistently.
ui/lib/sp_ui_web/live/emergence_world_live.ex — Phoenix LiveView world renderer per UNI POV.
viewer/emergence_pov.js — per-UNI Playwright POV capture.
viewer/vision_forward.cjs — unchanged (already MODE / STREAM / VIEW_URL-parameterised).
lib/mix/tasks/sp_emergence_clone.ex — mix sp.emergence.clone (clones EmergenceAI/Emergence-World as sibling).
lib/mix/tasks/sp_emergence_spec.ex — parses upstream into runs/emergence/spec_dump.json.
lib/mix/tasks/sp_emergence_deploy.ex — mix sp.emergence.deploy --world ... --cohort ... --mature-from ....
lib/mix/tasks/sp_emergence_awi.ex — replay + AWI / U-metric computation.
lib/mix/tasks/sp_emergence_replay.ex — mix sp.emergence.replay <date> deterministic replay.
test/sp/emergence/*_test.exs — codec, actions, world_sim, mating, governance.

Risks + mitigations

Upstream license (CC BY-NC 4.0): research-only, non-commercial — covered. Attribution to EmergenceAI/Emergence-World at the top of this document and in lib/sp/emergence/world.ex @moduledoc.
WorldSim fidelity: a rebuild from public specs may diverge from Emergence AI's reference implementation. Mitigation: every constant traceable to a published source citation; spec_dump.json is the auditable bridge; pre-registered acknowledgement that fidelity is "as published".
Mating-induced population blow-up: cross-kin children accumulate kin archives. Mitigation: mix sp.lineage.prune --keep-fittest 6 periodic; cap max_pop per kin; the Town-Hall vote is itself a population brake.
Vision capture cost: 10 headless Chromes ≈ 2 GB RAM. Mitigation: mosaic fallback pre-registered (one Chrome, 10 sub-rect viewports).
Codec semantic drift: re-mapping :status/:inventory/:vision to Emergence semantics is silent but MC.compatible?/2 is shape-only. Mitigation: option (b) sandbox pre-train (recommended) eliminates the drift entirely; tag every .bin with world: "emergence" metadata at save time (one-line addition to MC.save/2); mix sp.uni.prove chapter on Dirichlet growth still bites.
The BEAM already runs the Minecraft pipeline: running both concurrently is supported (separate SP.Runtime.Supervisor shards by username) but worth flagging. Mitigation: namespaced env (EM_*), no module shared mutably except SP.Runtime.Board (keyed by username).
Confirmation bias: H1 is pre-registered here; a negative result is publishable. The discipline is the falsifier criteria, frozen in this document before the run.

End-to-end verification

The plan is fully working when, on a fresh checkout, the following sequence is byte-identical for a fixed seed and reproducible by a third party:

mix deps.get && mix compile succeeds with zero hex deps added.
mix sp.brain.verify && mix sp.uni.prove && mix test all green — the existing Minecraft pipeline is untouched.
mix sp.emergence.clone writes ../Emergence-World and mix sp.emergence.spec produces runs/emergence/spec_dump.json deterministically.
mix sp.emergence.codec.smoke deterministic against checked-in golden σ-stream.
mix sp.emergence.deploy --world sandbox --cohort 1 --seed 1 --steps 200 runs one UNI for 200 ticks; the Board row shows energy / knowledge / influence and a non-empty action history; the :scene factor's Dirichlet counts have grown (verifiable via runs/colony/kin-0.bin size + mix sp.uni.prove chapter).
mix sp.emergence.deploy --world sandbox --cohort 10 --days 5 matures ≥ 9 / 10 UNIs to phase >= 3 (the pre-train pass criterion).
Mating fixture: two phase 4 UNIs in the same landmark, both choose :mate for 4 consecutive beats → SP.Runtime.Mating spawns a child via Supervisor.spawn_agent, the child posts its citizenship proposal, runs/lineage/cross_kin.ndjson gains a row. Unit-tested in test/sp/runtime/mating_test.exs with mocked Supervisor + Board.
Vision smoke: a 10-minute capture run shows the per-UNI scene-state file updating and the brain's :scene factor posterior entropy dropping (mix sp.uni.prove chapter passes).
Production replay: mix sp.emergence.replay <date> reproduces every Board snapshot at every tick from the recorded NDJSON exactly.
After the 15-day run, mix sp.emergence.awi runs/emergence/season-1/ produces a deterministic AWI + U-metric report comparable to Emergence's published Season 1.

sha256 4b356fc8ed2f34ae — 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 is an implementation plan, not a result. It proposes porting this project's agents into a locally rebuilt simulation of a world specified by another group, and writing down what would count as a match before running anything, so the bar cannot be moved afterwards, then comparing against that group's published outcomes.

The hypothesis is stated as a hypothesis. In the published season, no cohort of language-model agents grew its population; two collapsed entirely and two held steady. The plan predicts this project's agents will do better, by growing the population through a path the constitution allows but no published cohort took. It says plainly that a negative result is publishable, and that freezing the criteria in this document before the run is the discipline.

Because the other repository publishes specifications rather than an engine, the plan rebuilds the world locally, which it argues makes the experiment self-contained and reproducible.

The rest is a long numbered sequence, from cloning specifications through to publishing replayable records.

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

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 an implementation plan with a pre-registration attached, its conditions written down before the run. It carries an attribution note explaining that the world it targets is specified by another project under a non-commercial licence, while the simulator here is an original rebuild.

The context section summarises a published experiment in which several parallel worlds were each populated with language-model agents for a fixed number of days under a shared constitution. The published population outcomes are given: two cohorts collapsed entirely, one lost members, and two held steady. The line that matters is that no cohort grew its population, because a governance gate on births was never crossed. The working hypothesis is stated as a hypothesis: that this project's agents will avoid the collapse and also exceed the holding baseline by growing the population through a mating-and-citizenship path the constitution allows but no published cohort took.

A practical observation follows. A read-only fetch showed the upstream repository publishes specifications and results but no engine. So the plan is a faithful local rebuild rather than a deployment onto someone else's system, which it argues makes the experiment self-contained, reproducible and free of a third-party runtime dependency.

The recommended approach keeps the existing decision core untouched and world-agnostic, and adds three new pieces. The first is a deterministic simulator of the grid, running turn-based under a real-time clock with decay, an economy and a voting threshold. The second is a bridge that replaces the process boundary with an in-process one, so the brain still only ever sees numbers keyed by numbers. The third watches for two co-located agents that have both signalled willingness, recombines their inherited material, and spawns a child whose first act is to propose its own citizenship. Vision is reused almost unchanged from the existing pipeline.

A long numbered sequence then covers the whole of it. It starts with cloning the specifications and consolidating them into a machine-readable dump, then the data layer, the simulator, and the translation of senses and actions into this world's vocabulary. Then governance, economy, the mating subsystem, vision plumbing, a camera re-point, and extensions to the verification harness. Then a sandbox pre-training run with a stated pass criterion, and the commit that writes the conditions down before the run. Then the production run, a mid-run safety net that halts the deployment automatically if any gate fails, the final analysis, and publication.

Two details stand out. The mating action is described carefully as a public co-located signal rather than a decision to mate, with the actual recombination happening elsewhere. And a child lives as an observer until its citizenship proposal passes, so its birth into the public world is itself part of the record.

The risks section is candid. The rebuild may diverge from the reference implementation, and the mitigation is that every constant traces to a published citation with a pre-registered acknowledgement that fidelity is only as published. Population growth could run away, so pruning and a cap are named alongside the vote itself as a brake. Vision capture has a memory cost with a fallback registered in advance. A silent semantic drift in the translation layer is named, with the sandbox pre-training as the mitigation. And confirmation bias is addressed directly: the hypothesis is pre-registered here, a negative result is publishable, and the discipline is that the criteria are frozen before the run.

The closing section defines what finished looks like as a sequence of commands that must be reproducible by a third party from a fresh checkout at a fixed seed.

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