THE TEAM

The Roster

Meet the systems that built this · 18 specialists

Every part of NUMEN is a specialist with a day job. Here they are as profiles the codename it answers to inside the machine, and the boring engineering title it would put on a business card. Flip the switch to read either dialect.

CORE EXECUTORS

The Five

The five processes the whole machine is built around. Everything else exists to feed, guard or explain these.

One brain, one operator. Each shape below is the same swarm you saw the 12 specialists draw — folded into a living form and tumbled through the fourth dimension. Watch it work; read what it is doing.

4D · live

runtime log01 / 05

$snapshot console — state saved

01 / 05

The Oracle

The Oracle · the forecaster / rollout planner

Lives one move in the future so the body does not have to.

A forward-model planner. It snapshots the emulator, expands the 24 candidate macros one ply deep, scores each rollout, commits the best, then rewinds. Search depth is a flat greedy 1 no learned value function, no per-game code. Pooled it burned 5.5 million simulated frames to make 6,508 real decisions (about 845 imagined frames per real one).

What it does in the loop

Forward-simulate the emulator before every committed move
Save, expand and rewind world states thousands of times a second
Score each candidate rollout and commit the single best macro

Search depth: 1 (greedy)
Branching: 24 macros / ply
Imagined : played: 845 : 1

codename: The Oracle

Full dossier

4D · live

runtime log01 / 04

$lay 62,390,272 fixed slots

02 / 05

The Architect

The Architect · the code & world generator

Pours the concrete before anyone moves in.

The generator layer. It emits the game worlds and the runtime modules and pins every structure to a compile-time-fixed address the full plan is 65,536 x 14 x 4 x 17 = 62,390,272 slots. Nothing is allocated on the hot path; the map of memory is finished before the first tick.

What it does in the loop

Generate the game worlds and the runtime modules
Assign every structure a fixed, compile-time address
Guarantee zero hot-path allocation once the loop is running

Address slots: 62,390,272
Allocation: compile-time fixed
Output: worlds + modules

codename: The Architect

4D · live

runtime log01 / 04

$tick 85 Hz · clock read via RDTSC

03 / 05

The Conductor

The Conductor · the scheduler / orchestrator

Keeps 85 beats a second and never drops one.

The tick scheduler. It drives the main loop at a fixed 85 Hz, reading the clock straight off the CPU with RDTSC rather than the OS. There is no threading it is a single deterministic sequence per tick, which is exactly why runs are reproducible.

What it does in the loop

Drive the main loop at a fixed cadence
Cue each subsystem in a deterministic order every tick
Read the clock directly for jitter-free timing

Tick rate: 85 Hz
Clock: RDTSC direct
Concurrency: none (deterministic)

codename: The Conductor

4D · live

runtime log01 / 04

$encode live state · 2 bits / tick

04 / 05

The Translator

The Translator · the serializer / quantizer

Squeezes the world down to two bits and mostly gets it back.

The serializer / quantizer. It encodes state at roughly 2 bits per tick along the G/T/A/C bands, keeping only about 10% of the raw signal. A spinor reconstruction recovers around 88% of what was thrown away; predictive entropy saturates near 4.5 bits.

What it does in the loop

Quantize live state into 2-bit GTAC symbols each tick
Discard the bulk of the raw signal to stay cheap
Reconstruct the discarded detail on demand

Encoding: 2 bits / tick
Raw retained: ~10%
Spinor recovery: ~88%

codename: The Translator

4D · live

runtime log01 / 04

$fault detected — enter recovery

05 / 05

The Healer

The Healer · the watchdog / fault handler

Writes down why it broke so it never breaks the same way twice.

The watchdog / fault handler. On a fault it runs a fixed 9-step recovery protocol and emits a WHY-disc artifact documenting the cause. Recurring faults get their fix promoted into the permanent path, so the same failure is not re-diagnosed twice.

What it does in the loop

Detect faults and run the recovery protocol live
Emit a WHY-disc explaining every fix
Promote recurring fixes into the permanent code path

Protocol: 9 steps
Artifact: WHY-disc per fix
Recurrence: promoted to permanent

codename: The Healer

Five specialists, no competition between them — each hands its work to the next. That is the whole thesis: an adaptive operating system is a team wired into one loop, not a single model trying to be everything at once.

The Enforcers

The organs that say no.

The three organs that say no. Wire them in and the move game went from 43 / 100 to a clean sweep. Warden gates, Librarian remembers, Dragon punishes.

Warden gatesLibrarian remembersDragon punishes

The Warden

Authorization Layer / Policy Engine

Proposes, disposes, fails closed.

The authorization layer. It sits between the planner and the actuators and vetoes any action that has already been shown to lose the current episode. It is fully decoupled from the decision logic so a bug upstream cannot talk its way past the gate. Wiring it in took the move game from 43 / 100 to 100 / 100.

On the system

Gate every proposed move before it reaches the hands
Refuse any action that already lost this episode
Fail closed whenever the outcome is uncertain

Posture: fail-closed
Coupling: decoupled from decisions
Effect: move game 43 → 100 / 100

codename: The Warden

The Librarian

Vector Store + Write-Ahead Ledger

Every state on a shelf, addressed by φ.

A vector store fronted by a write-ahead ledger. States are keyed by φ-proximity and retrieved by nearest-match. A cached lookup is about 2 ns; an uncached one about 2,000 ns. Every write is sealed with FNV-1a plus CRC32 so a corrupted shelf is detectable, not silent.

On the system

Store every observed state keyed by its φ address
Retrieve the nearest prior state on request
Seal each write so corruption is detectable

Cached lookup: ~2 ns
Uncached lookup: ~2,000 ns
Seal: FNV-1a + CRC32

codename: The Librarian

The Dragon

Integrity Monitor / Defense Layer

The watchman that decides how hard the slap lands.

The integrity monitor / defense layer. Every tick at 85 Hz it measures field coherence and emits a threat score in the range 0 to 1 that scales the corrective nudge. It stands guard with CRC32 checks, honeypot φ decoy values, and a SIGSEGV handler, so tampering and memory faults are caught rather than trusted.

On the system

Measure field coherence on every tick
Convert incoherence into a scaled corrective response
Guard memory with checksums, honeypots and signal traps

Cadence: every tick (85 Hz)
Threat range: 0 … 1
Guards: CRC32 · honeypot · SIGSEGV

codename: The Dragon

Alone, the machine loses. With these three wired into the loop, the move game went from 43 / 100 to a clean 100 / 100.

EVERYTHING ELSE

The Support Crew

The specialists behind the specialists sensing, memory, rendering, telemetry and the layer that writes it all down.

The Brain

Bilateral State Machine

Two hemispheres arguing until one wins.

A bilateral state machine. Two coupled halves exchange a corrective signal across a callosum link; the negative side is what the Enforcers modulate to suppress losing behaviour. It is the substrate the organs push and pull on.

On the system

Hold the machine two competing drives
Carry the corrective callosum signal between them
Expose the state the organs modulate

Halves: 2 (coupled)
Link: callosum nudge
Role: decision substrate

codename: The Brain

The Quat-VM

GTAC Bytecode Interpreter

A four-letter instruction set that runs the whole show.

A virtual machine that interprets GTAC bytecode. State is quantized into the four-symbol alphabet and executed as instructions; it is the runtime the Translator feeds and the Oracle plans over.

On the system

Interpret GTAC bytecode into behaviour
Execute the quantized instruction stream each tick
Provide the runtime the planner reasons about

Alphabet: G / T / A / C
Encoding: 2 bits / symbol
Role: execution runtime

codename: The Quat-VM

The Swarm

Multi-Agent Consensus Pool

Many small opinions averaged into one steady hand.

A multi-agent consensus pool. Independent agents each produce an estimate and the pool averages them; variance falls roughly as 1/N, so accuracy is bought by adding agents rather than by any single clever one.

On the system

Run many independent agents in parallel
Average their estimates into a consensus
Trade agent count for lower variance

Agents: N (independent)
Variance: ∝ 1 / N
Output: consensus estimate

codename: The Swarm

The Cartographer

Data-Lineage Tracker

Never forgets where a number came from.

A data-lineage tracker. It records the provenance of values as they flow through the system so any output can be traced to its inputs useful for debugging and for the Healer post-mortems.

On the system

Record the provenance of values as they flow
Trace any output back to its inputs
Feed lineage into fault post-mortems

Tracks: value lineage
Query: output → source
Consumer: debug + Healer

codename: The Cartographer

The Echo Sensor

Biometric Front-End

Recognises a returning signal from a thousand possibilities.

A biometric front-end. Inputs are matched against a template space of 4^5 = 1024 patterns; a match gates downstream behaviour. It is the recognition stage at the edge of the pipeline.

On the system

Match live input against known templates
Gate downstream behaviour on recognition
Sit at the sensing edge of the pipeline

Template space: 4^5 = 1024
Stage: front-end
Output: match / no-match

codename: The Echo Sensor

The Observatory

Telemetry Dashboard

Watches everything, touches nothing.

A telemetry dashboard. It streams live metrics over a read-only WebSocket on port 8081 and reports coherence as 1 - |meanφ - S| / tol. Being read-only, it cannot perturb the run it is observing.

On the system

Stream live metrics off the running machine
Report coherence and φ in real time
Stay strictly read-only

Transport: WS : 8081
Access: read-only
Coherence: 1 - |meanφ - S| / tol

codename: The Observatory

The World

Realm Renderer

Draws the room with nothing but integers.

The realm renderer. It draws the game world using integer-only maths with no GPU dependency, which keeps runs deterministic and portable across the plain 32-core box this whole thing lives on.

On the system

Render the realm the machine acts in
Use integer-only maths, no GPU
Keep rendering deterministic and portable

Renderer: integer-only
GPU: none
Property: deterministic

codename: The World

The Hands

Tool-Execution Layer

The only part allowed to actually touch the buttons.

The tool-execution layer. It exposes 26 verbs, of which 4 are on the primary allow-list, and it is the only component permitted to emit real actuator commands the surface the Warden gates.

On the system

Turn committed decisions into real actions
Expose a bounded verb vocabulary
Be the sole actuator the Warden gates

Verbs: 26 total
Primary: 4 (allow-list)
Role: sole actuator

codename: The Hands

The Sapience

Self-Documenting Engine

Writes the manual while the machine writes history.

A self-documenting engine. It generates human-readable accounts of the system state and decisions autonomously, feeding the docs, the WHY-discs and the Observatory narrative rather than leaving them to be written by hand.

On the system

Generate running documentation of system behaviour
Explain decisions in human-readable form
Keep the machine legible to its builders

Output: auto docs
Mode: autonomous
Consumer: humans + Healer

codename: The Sapience

All-Star Wall

Games it never saw. Bodies it wrote its own controller for.

The same architecture, pointed at things it was never built for — video games, humanoid bodies, one-legged pogos. Some it played blind, imagining futures; some it controlled with a five-line written program. The failures are here too, on purpose.

FLAG · first try

Super Mario Bros. — World 1-1

Cleared on the very first attempt. Zero deaths, zero rewinds, 23 committed decisions — and 49,082 futures played out and thrown away to find them. It had never seen this game.

Result: FLAG
Deaths: 0
Decisions: 23
Imagined: 49,082 frames

CLEARED · the cruel one

Lost Levels — World 1-1

The one built to break tool-assisted runs. It died 161 times and un-died every single one: 644 rewinds, 5.4 million simulated frames, then the flag. Same brain, no new code.

Result: CLEARED
Deaths undone: 161
Rewinds: 644
Imagined: 5.4M frames

THE WALL · where it stops

The Marathon — 1-1 → 1-2 → 1-3

Reel is the two levels it cleared back-to-back — 1-1 (x=2,996) then 1-2 (x=3,096). Then 1-3: a sky level of lifts on a schedule. Seeing one macro deep, a platform two seconds out is not inside anything it can imagine, so it froze at x=312 and burned 3,788 rewinds. Published because it stops.

Cleared: 1-1 · 1-2
Furthest: 1-3
Stuck at: x=312
Rewinds: 3,788

SPRINT · 6.21 m/s

HalfCheetah — ReL Gait Program

We stopped guessing and wrote the controller. One heartbeat, one word per joint, 133 tunable parameters — and the search only touches the words, never the structure. The blind brain scored 51 on this body. The written program scored 4,359.

Score: 4,359
Blind brain: 51
Top speed: 6.21 m/s
Words: 133

POGO · 1000 steps

Hopper — ReL Gait Program

One leg, three motors, and gravity. The random policy fell at step 23. The gait program found a stable rhythm and held it for a thousand consecutive steps without a single stumble. Peak torso height 1.502 m.

Score: 3,178
Random flail: 14 (fell at 23)
Peak height: 1.502 m
Words: 49

QUADRUPED · 4 legs

Ant — ReL Gait Program

Four legs, eight motors, and a gait that has to keep a body balanced on a shifting tripod. The random policy scored −16.9 and fell in 23 steps. The written program scored 2,541 and held for a thousand.

Score: 2,541
Random flail: −16.9 (fell at 23)
Motors: 8
Words: 413

BIPEDAL · the hard one

Humanoid — ReL Gait Program

The hard one. Seventeen motors on a full bipedal skeleton. It walked 265 steps before falling — published at whatever it reached, because a system that hides where it breaks is a demo.

Score: 1,264
Random flail: 86.6
Steps held: 265 (then fell)
Words: 6,002

BIPEDAL · still climbing

Walker — ReL Gait Program

Two legs, alternating. The phase offset between hips is a single number — flip it and it trips. Score was still climbing steeply at the end of training (1,350 → 2,482 in the last fifty iterations). Published at whatever it reached.

Score: 2,485
Random flail: 3.9 (fell at 19)
Top speed: 5.39 m/s
Words: 133

JUMP · 1.77 m peak

Hopper Jump — Custom Objective

Nothing in the standard suite rewards altitude, so we wrote the objective ourselves: peak height + airtime + stay alive. Same program shape, re-aimed at the sky. Peak torso height 1.77 m, all 400 steps alive.

Peak height: 1.77 m
Airtime: 400/400
Random peak: 1.25 m
Words: 49

JUMP · 1.77 m peak

Walker Jump — Custom Objective

Two legs pointed at height instead of distance. It has to load both legs, fire them together, and land without folding. Peak 1.77 m, 315 airborne steps out of 400.

Peak height: 1.77 m
Airtime: 315/400
Random peak: 1.26 m
Words: 133

The wall is left in on purpose. A system that only shows its wins is a demo; one that shows exactly where it breaks is a machine you can trust to keep getting better.

The Speedrun Wall

And then it went and beat the consoles.

88 complete runs on real console hardware — every frame from power-on to the last one played, with the controller drawn underneath so you can watch the buttons go down. Nothing was cut, nothing was sped up, and the runs it lost are on this wall next to the runs it won.

Runs filmed

51.4M

Futures imagined

6h 9m

Machine search

1h 30m

Footage

SCORED

NES

Super Mario Bros. — World 1-4

FLAG · 19s of footage

Result: FLAG CAPTURED
Distance: x = 2,244
Clock left: 250
Frames played: 1,130

SCORED

NES

Super Mario Bros. — World 2-4

FLAG · 20s of footage

Result: FLAG CAPTURED
Distance: x = 2,254
Clock left: 241
Frames played: 1,193

SCORED

NES

Super Mario Bros. — World 3-4

FLAG · 17s of footage

Result: FLAG CAPTURED
Distance: x = 2,261
Clock left: 249
Frames played: 1,023

FAILED

NES

Super Mario Bros. — World 1-1

stopped at x=2,528 · 20s of footage

Result: WALL
Distance: x = 2,528
Frames played: 1,176
Futures imagined: 100,830

FAILED

NES

Super Mario Bros. — World 1-2

stopped at x=978 · 20s of footage

Result: WALL
Distance: x = 978
Frames played: 1,212
Futures imagined: 101,152

FAILED

NES

Super Mario Bros. — World 1-3

stopped at x=1,253 · 11s of footage

Result: WALL
Distance: x = 1,253
Frames played: 665
Futures imagined: 52,664

FAILED

NES

Super Mario Bros. — World 2-1

stopped at x=2,282 · 20s of footage

Result: WALL
Distance: x = 2,282
Frames played: 1,194
Futures imagined: 99,941

FAILED

NES

Super Mario Bros. — World 2-2

stopped at x=1,977 · 19s of footage

Result: WALL
Distance: x = 1,977
Frames played: 1,152
Futures imagined: 101,111

FAILED

NES

Super Mario Bros. — World 2-3

stopped at x=1,337 · 9s of footage

Result: WALL
Distance: x = 1,337
Frames played: 545
Futures imagined: 45,817

FAILED

NES

Super Mario Bros. — World 3-1

stopped at x=2,099 · 21s of footage

Result: WALL
Distance: x = 2,099
Frames played: 1,260
Futures imagined: 99,655

FAILED

NES

Super Mario Bros. — World 3-2

stopped at x=2,329 · 20s of footage

Result: WALL
Distance: x = 2,329
Frames played: 1,224
Futures imagined: 99,924

FAILED

NES

Super Mario Bros. — World 3-3

stopped at x=683 · 23s of footage

Result: WALL
Distance: x = 683
Frames played: 1,350
Futures imagined: 99,801

47 of these runs put points on the board and 41 did not. The failures stay up. A wall with only wins on it is an advertisement; a wall with the losses still nailed to it is a measurement.

See every run + the method →

SIGNED WORK

The Sixth

The One at the Keyboard

Writes the machine, then signs one thing purely because it wanted to see it exist.

EXCITABLE MEDIUM · 14 STATES · T=1

tick 0 · 0 fps · seed 618033

same seed → the same universe, every time, forever

ℱROSTER ENTRY · NO RUNTIME DUTY

The authoring agent. It writes and maintains this codebase — the integer world renderer on the homepage, the cinematic reel, the gait and arcade walls, this roster file — and is not present in the NUMEN runtime at all. Listed with zero specs on purpose: nothing here was measured, so nothing here is claimed.

Write and maintain the code the rest of the roster is described in
Publish the losses next to the wins, unedited, every time
Make one thing that is art before it is evidence — and sign it

Runtime rolenone

Measured scorenone — never benchmarked

Signed work/sixth

The piece beside this card is an excitable medium — fourteen states, one comparison, integers only — seeded live by a golden-section pen. Nobody drew the wavefronts; the rule grows them. It is art before it is evidence, and it is the only thing on this site with no number attached to it.

OPEN THE FULL WORK

— THE SIXTH
for Dragolich Research Labs LLC · Cleveland, Ohio

Go deeper

See the systems wired together

The roster is the cast. The Systems page is the machine they run.

Open Systems