UNI Universal Natural Intelligence

Wiki · The Colony & the Method

Runtime Boundary Validation

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

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.

Purpose

Verify Hard constraint #6 and Validation Invariants #3, #14, and the Jido runtime invariants: agent decision logic is pure, directives are the only path to effects, internal state ops never mutate the world, and baselines stay interface-constrained.

Method

  • Inspect the type of value the agent receives in decide/3 (must be an opaque int → number map).
  • Confirm a no-op agent leaves the world evolving solely by dynamics (the agent has no write path).
  • Confirm malformed/garbage directives are tolerated and never executed.
  • Confirm SP.Body state transitions return only a body (no world).
  • Confirm baselines return only Actuate directives.

Artifacts used

  • SP.SimTest (InspectAgent, NoopAgent, GarbageAgent), SP.InvariantsTest (#3, #14), SP.Body purity.

Result summary

  • Pure decision boundary: InspectAgent records that every observation it receives is an integer → number map — it has no reference to SP.World/ SP.Body (#3).
  • Effects only via the interpreter: with NoopAgent (returns []), the world still advances by dynamics (world.tick > 0, regions change) while the body's location/inventory only change when the interpreter applies a directive.
  • Directives can't smuggle mutation: GarbageAgent returns out-of-range and non-directive values; SP.Sim validates each (Directive.validate/1 + Interface.decode_action/2), counts decoded_failures > 0, executes none, and the episode completes without raising.
  • Internal state ops are world-free: Body.step/2 returns {%Body{}, telem}; it cannot reach the world (the Sim applies the world-side nutrient depletion).
  • Baselines interface-constrained: every baseline's decide/3 returns only %SP.Core.Directive.Actuate{} values (#14); Random/LeakageProbe never touch channel_map semantics.

Mapping to Jido invariants

Jido invariant Status
Signals are the primary unit PASS (SP.Core.Signal)
Sensors bridge events→signals PASS (SP.Body.Sensor)
cmd/2 pure PASS (SP.Agent.decide/3)
Directives describe effects, runtime executes PASS (SP.Sim is the sole interpreter)
State ops internal only PASS (SP.Body/SP.Sim)
Cross-agent via signals PASS (Emit/Schedule directives; no shared writes)
Ephemeral vs durable children Specified (SpawnWorker/StopChild; Jido adapter)
Layered testing, no sleeps PASS (no Process.sleep in suite)

Durable, falsifiable record (Observer/Recorder/Verifier)

SP.Sim.Observer records a per-tick frame proving the boundary held: the only world→agent datum is the opaque observation (afferent.observation), and the agent→world data are the recorded directives/decoded actions (efferent). SP.Sim.Verifier independently recomputes the no-leak verdict from the log, and faithful?: true removes the channel map from the agent's context so the observation is provably the sole world-derived input (recorded as blanket.context_redacted, asserted by SP.Sim.BlanketTest). The recorder is a pure read (default off); determinism is unaffected (tested ON vs OFF).

Pass/Fail

PASS.

Residual risks

  • The live Jido.AgentServer wrapping is specified, not compiled into the offline core (see jido_alignment.md). The pure interpreter enforces the same boundary the adapter would.

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

Plain — written for this website, not the source document

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. (or choose Precise in the reading-level control above)

This report checks that the deciding part of the system cannot reach out and change the world by itself. It may only return instructions, and something else carries them out.

The method is a set of deliberately awkward agents. One records exactly what type of value it is handed and shows it is nothing but numbers keyed by numbers. One returns nothing at all, so the world should keep evolving on its own while the body stays put. One returns garbage, and the runtime should validate it, count the failures, execute none of it, and finish the episode without crashing.

A table then maps each of a set of runtime design rules to a status, with one marked as specified rather than compiled in.

The last section is the strongest. A recorder writes a per-tick record, and a separate verifier recomputes the no-leak verdict from that record independently.

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

Clear — written for this website, not the source document

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. (or choose Precise in the reading-level control above)

This report verifies a boundary. The agent's decision logic must be pure: it may return instructions, and only the runtime may turn those into effects. Internal body operations must never touch the world, and the scripted strategies must stay as constrained as any learner.

The method is a set of deliberately awkward test agents. One inspects and records the type of value it is given, to confirm it is nothing richer than a mapping of numbers to numbers with no reference to the world or body modules. One returns no instructions at all, so that the world should continue to advance by its own dynamics while the body's position and inventory stay unchanged. One returns out-of-range and non-instruction values, so that validation and decoding should reject them, count the failures, execute none, and let the episode finish without raising.

The results follow those three in order and add two more. Body state transitions return only a body and telemetry, so they cannot reach the world at all, with the world-side consumption applied by the simulation instead. And every scripted strategy returns only one kind of instruction, with the random and probing strategies never touching the meaning of the channels.

A table then maps a set of runtime design rules onto statuses. Most pass with a named implementation. One is marked specified rather than implemented, and that row is what keeps the table honest.

The strongest section is the durable record. A recorder writes a frame per tick showing that the only thing crossing from world to agent was the opaque observation, and that the only things crossing back were the recorded instructions and decoded actions. A separate verifier recomputes the no-leak verdict from that log independently. In a stricter mode the channel mapping is removed from the agent's context entirely, so the observation is demonstrably the sole world-derived input, and that removal is itself recorded and asserted by a test. The recorder is a pure read, off by default, and determinism was tested with it both on and off.

The verdict is a pass, and the residual risk repeats that one live wrapper is specified rather than compiled into the offline core, with the note that the pure interpreter enforces the same boundary the adapter would.

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