FTNFor The Nerds

The Decoder Ring

A learning journey through a machine that talks funny

NUMEN was built alone, at night, in a private vocabulary. This page runs every one of those words through a translator and hands you back the boring, correct, engineering term underneath. Flip the switch at any time and read it the other way.

Jump to all 133 terms

Highlighted words carry both names. Hover any of them to see the other side. Where no accepted term existed, one has been coined and marked as such — that is the honest state of the vocabulary, not a claim that the field agreed on it.

133

terms in the decoder

every NUMEN-ism, mapped

85 Hz

tick rate

fixed quantum, RDTSC-derived

2 bits

per decision

four gates, hard thresholds

1000×

cached vs. uncached

~2 ns against ~2,000 ns

845 : 1

imagined per played frame

measured over two runs

GPUs

one 32-core CPU, 247 GB RAM

The journey

Twelve stops, from the clock at the bottom to the thing currently pressing buttons on a game controller. Each one names the strange word, gives you the boring word, and shows the measurement.

Discrete time step

Everything starts with a heartbeat.

There is no event loop, no framework, no scheduler handed down from a runtime. There is one integer counter that increments, and every single thing the system does happens inside one increment of it. That is the tick.

The clock source is RDTSC — the CPU's own cycle counter, read directly. The loop is pinned so that one tick lands every 1/85th of a second. Nothing is asynchronous. Nothing is deferred. If work does not fit inside a tick, it does not happen inside that tick.

The upside of a fixed quantum is that every measurement on this page has the same denominator. The downside is that the whole machine is single-threaded and strictly sequential — which is a real ceiling, and it is listed in the limitations at the bottom.

Tick rate: 85 Hz nominal
Clock source: RDTSC, read directly
Concurrency: None — one core, sequential

Hardware timing-jitter entropy

The randomness is not generated. It is harvested.

Two consecutive RDTSC reads should be a fixed distance apart. They never are. Thermal drift, pipeline stalls, cache misses, interrupt shadows and speculative execution all smear the delta by a handful of cycles. Most software treats that smear as measurement error and averages it away.

NUMEN treats it as the input. The variation between consecutive cycle-counter reads is the entropy source that feeds the whole stack. There is no PRNG seed, no /dev/urandom, no external randomness at all in the core loop.

This is also the single most environment-sensitive claim in the project, and it needs saying plainly: under a hypervisor, TSC reads get trapped and quantized. The jitter shrinks. Every entropy number here is host-dependent and will not reproduce identically on a virtual machine.

Source: RDTSC delta variance
External RNG: None in the core loop
Caveat: Degrades under virtualization

Scalar control variable

The entire belief state of the machine is one number.

Not a tensor. Not a hidden layer. One Q32.32 fixed-point accumulator — 32 bits of integer, 32 bits of fraction — holding a value between 0 and 1. That single register is what the system "thinks" right now.

Fixed point rather than floating point is a deliberate call. It makes every arithmetic operation bit-exact and perfectly reproducible across runs and machines, which matters enormously when your entire result is "the number converged to here." No denormals, no reassociation surprises, no compiler flag changing the answer.

The number it is aiming for is φ⁻¹ = 0.6180339887498949, the reciprocal of the golden ratio. Be honest about why: the setpoint is chosen, not discovered. Convergence holds for any target in the open interval, and the golden ratio was picked because it is the hardest number to approximate with rationals, so the orbit around it is the last one to lock up.

Representation: Q32.32 fixed point
Setpoint: 0.6180339887498949
Honest note: Setpoint chosen, not derived

First-order IIR feedback controller

One line of arithmetic runs the whole machine.

phi += K * (setpoint − phi). That is it. That is the law. It is a first-order infinite-impulse-response filter, or equivalently a discrete contraction mapping, and it is the oldest trick in control theory.

Because 0 < K < 1 the map is a strict contraction, so the Banach fixed-point theorem applies: there is exactly one fixed point, and the error to it decays geometrically from any starting value. That is not a claim about intelligence. It is a two-line proof from 1922, and it is the reason the system never diverges no matter what the entropy stream throws at it.

The loop gain K = 0.07585880 is the base rate. On top of it sits gain scheduling — K gets modulated by which regime the error is in. Warmup ramps K from zero to avoid overshoot. Exploit relaxes it to fine-tune. Plateau detects a stall and injects dither to escape. Divergence backs K off so a shock does not set up an oscillation.

Update: phi += K·(S − phi)
Base gain K: 0.07585880
Guarantee: Banach — unique fixed point

2-bit scalar quantizer

A continuous number gets crushed into two bits, on purpose.

The controller produces a smooth value. Nothing downstream wants a smooth value — routing, action selection and storage all want a symbol. So phi passes through four hard thresholds and comes out as one of G, T, A or C.

G is the floor region below 0.605. T is the approach band from 0.605 up to 0.620. A is the attractor-aligned centre from 0.620 to 0.630. C is the ceiling above 0.630. Four bins, two bits, one symbol per tick.

This is lossy and the loss is measured, not hand-waved: 2-bit encoding retains roughly 10% of the predictive information in the signal. That is a brutal number and it is the main bottleneck in the whole pipeline. The mitigation is spinor encoding — re-expanding the scalar into a (cos, sin) pair before quantizing — which recovers about 88% of what the hard threshold threw away.

Bins: 4 (G / T / A / C)
Retention: ~10% of predictive info
Spinor recovery: ~88% of the loss

Uncommitted state vs. checkpointed record

The only line that matters is the one between thinking and doing.

A value on the wire is a proposal. It is cheap, it is reversible, and nothing outside the process can see it. A value written to disc is a fact — a sealed, checksummed, fsync'd record that survives the power going out. The transition between the two is the only place where the machine touches the world.

Every commit path funnels through one write barrier. Nothing skips it. The record carries an FNV-1a hash over its canonicalized fields as a tamper-evident seal, and a CRC32 anchor over the critical state. That gives you an append-only audit trail where every action the system ever took can be replayed in order.

FNV-1a is fast and it is not a MAC. It detects accidental corruption and casual tampering. It is not collision-resistant and it should never be described as cryptographic. If you need that guarantee, hash the disc with sha256sum.

Barrier: Single commit point, fsync'd
Seal: FNV-1a + CRC32 anchor
Honest note: Tamper-evident, not cryptographic

Hamming-space content-addressable store

Memory is not a list. It is a shape, and near means near.

Conventional software uses a flat address space: an integer index into a linear array, where address 41 and address 42 have nothing to do with each other. NUMEN does not. Addresses are vertices of a Boolean hypercube, and two states are adjacent when they differ by exactly one bit.

Proximity is XOR popcount — count the differing bits and that is the distance. Related states therefore land in adjacent cache lines by construction, so the geometry of the memory model and the geometry of the CPU cache are the same geometry. Traversal follows a Gray code so consecutive addresses differ by one bit and never glitch through an invalid intermediate.

A state near the attractor is cached and resolves in O(1). A state far from it has to be scanned for, in O(n). The measured spread is about 2 ns for a cached lookup against about 2,000 ns for an uncached one — a factor of a thousand. "Learning," at this layer, literally means moving a symbol from the second column into the first.

Topology: Boolean lattice, Gray-code walk
Cached: ~2 ns
Uncached: ~2,000 ns

Prime-indexed lookup table

Turning a number into an address without a hash table.

To find something you need an index. NUMEN derives one straight out of the state register: a fixed-point multiply, a modulo, and out falls an integer from 0 to 206. That integer is the address, and each of the 207 slots is anchored to a prime.

This is multiplicative hashing with a golden-ratio multiplier, which is a genuinely old and well-understood technique — Knuth wrote it up decades ago — and the reason it is used is that the golden ratio spreads sequential inputs across the table more evenly than almost any other constant.

Nothing is allocated, nothing is rehashed, nothing grows. The address space is fixed at compile time and the lookup is a couple of integer operations. That is why it holds at tick rate on one core with no accelerator.

Address range: 0 … 206
Method: Multiplicative hash, φ multiplier
Allocation: None at runtime

Meta-control / hyperparameter scheduling

The outer loop tunes the inner loop while it runs.

The inner loop has one knob: K. The outer loop watches the loss trajectory and turns that knob. That is the whole of what is called learn-to-learn here, and calling it meta-control is more honest than calling it meta-learning, because no weights are being learned — a scalar schedule is being adapted.

Reinforcement is asymmetric on purpose. A gate that led to improved proximity gets its bias raised sharply. A gate that led to stagnation gets it lowered only slightly. On top of that sits a slow drift back toward uniform, so no single gate can monopolise the routing just because it won early.

Capacity only grows after the current stage has settled — error under threshold for a sustained window. That is stage-wise curriculum scheduling, and it is the reason the thing does not blow up when you scale it: it refuses to get bigger until it has stopped moving.

What is adapted: Loop gain K, gate bias
Reinforcement: Asymmetric + decay to uniform
Growth rule: Only after convergence

Effectuator / tool-execution layer

Deciding is free. Doing is gated.

The action set is not open-ended code execution. It is an explicit allow-list of command-line verbs invoked by fork and exec, with output folded back into the input stream. In the current runtime that is 26 verbs, of which 4 are primary. This is function calling, plainly.

Between intent and execution sits a separate authorization layer that the decision loop cannot modify. It evaluates the proposed action against a level-of-autonomy grade, from advisory all the way up, and blocks anything that fails a pre-execution check before it can reach the executor.

When something does go wrong there is a fixed nine-step remediation cascade — detect, propagate, isolate, prescribe, consent, treat, verify, release, immunize — and each treatment writes a rationale record explaining why it fired. Recurrence promotes the fix from a patch to a permanent change.

Action set: 26 verbs, 4 primary
Gate: Decoupled authorization layer
Honest note: Curated tools, not general execution

Telemetry dashboard

If you cannot watch it, you cannot claim it.

Every tick dumps a JSON snapshot — the state register, the active gate, fitness, coherence, anomaly count. A WebSocket on port 8081 streams it live at the full 85 Hz, and the dashboard fuses every running subsystem into one view.

Coherence is defined and computed, not vibed: 1 − |mean_phi − S| / tolerance, where 1 means fully converged. Predictive entropy is reported in bits. The information cascade from raw jitter through the state register to the emitted gate is strictly decreasing, which is exactly what the data-processing inequality says has to happen and is worth checking rather than assuming.

The stream is receive-only. There is no command broker on that socket and nothing can be injected back into the running system through it. That is a deliberate limit, not an oversight.

Transport: WebSocket :8081, 85 Hz
Coherence: 1 − |mean φ − S| / tol
Direction: Read-only telemetry

Save-state rollout planner

Emulate inside the emulation.

The newest piece of the stack does not run on the substrate at all — it drives a game controller. Save the emulator state, imagine every available future from it, rewind, then press the one button that scored best. Depth-one greedy search over 24 macro actions, with a coast base policy.

The measured trade is the whole point. Across two runs the planner burned 5,497,609 simulated frames to buy 6,508 real ones — a ratio of 845 imagined frames per frame actually played. In wall-clock terms that is 25 hours 27 minutes of imagination in exchange for 1 minute 48 seconds of play.

It cleared Super Mario Bros 1-1 with zero deaths and zero rewinds in 23 decisions, and cleared Lost Levels 1-1 through 161 deaths and 644 rewinds. It also wedges: the marathon run sticks in 1-3 and never gets out, and on Lost Levels it loops the same jump forever with every branch scored at −20,000. There is no per-game code, no training, no guide and no learned weights anywhere in it. It does not solve AGI. It does play a controller, and that is a genuine step.

Imagined : played: 845 : 1
Totals: 5,497,609 sim frames → 6,508 real
Known failure: Wedges in SMB 1-3, unsolved

The decoder ring

Every weird word, translated

133 entries. Left column is what the system calls it. Right column is what it actually is in normal engineering language, with the reason underneath. Nothing here is decoration — each pair maps to a real thing in the running code.

showing 133 / 133

Core System

the tick

Discrete time step / Scheduling quantum

Fixed 85Hz cycle derived from RDTSC; the atomic unit of work

the jitter

Hardware timing-jitter entropy / CPU jitter

Non-deterministic variation in RDTSC deltas from thermal/pipeline noise

System State (phi)

Scalar control variable / Continuous state register

Q32.32 fixed-point accumulator holding the current system belief

the wave

Continuous time-series signal / Entropy source stream

The raw pre-quantization sensory input

reading the wave

Signal sampling / Entropy extraction

Sampling RDTSC and folding it into the state register

the breath

Operational phase / Duty cycle

The rhythmic expansion/contraction of the control loop's exploration

oxygen

Exogenous information / External surprise signal

The world-data stream that injects novelty into the predictor

surprise

Prediction error / Tracking residual

The magnitude of |phi - setpoint|; the quantity minimized by the controller

down river

Information cascade / Data-processing pipeline

The strictly forward flow of information through processing stages

Control Theory

the one law

Linear feedback controller / First-order IIR filter

phi += K*(setpoint - phi

the attractor

Fixed setpoint / Reference value

The scalar value S that the control loop converges toward

contraction

Contraction mapping / Gain-scheduled convergence

The Banach contraction that guarantees geometric error decay

LR_ECHO

Damping coefficient / Loop gain

K = 0.07585880, the base convergence rate

the Banach step

Belief update / State transition

The discrete iteration of the contraction map

gain scheduling

Adaptive gain / Phase-based gain modulation

Dynamically adjusting K based on error variance

Mastered phase

Converged / Settled steady-state

Error below threshold with low variance; system at rest

Plateau phase

Stuck state / Local minimum

Error stagnant above threshold; requires dithering to escape

Divergence phase

Error spike / External shock response

Error increasing; gain is backed off to prevent oscillation

Warmup phase

Initialization ramp / Soft start

Gradual K increase from zero to nominal to avoid overshoot

Exploit phase

Converging / Exploitation

Error dropping cleanly; K is relaxed to fine-tune

learn-to-learn

Meta-control / Hyperparameter scheduling

The outer loop that adjusts K based on loss trajectory

Quantization & Encoding

GTAC gates

2-bit scalar quantizer / Quaternary encoding

Maps continuous phi to 4 discrete levels G/T/A/C via hard thresholds

the gates

Quantization bins / Decision classes

The four discrete symbols used for routing and action

G-gate

Low-entropy bin / Floor region

phi < 0.605

T-gate

Approach region / Transition bin

0.605 <= phi < 0.620

A-gate

Attractor-aligned bin / Center region

0.620 <= phi < 0.630

C-gate

High-entropy bin / Ceiling region

phi >= 0.630

the Born rule

Probabilistic collapse / Categorical sampling

Selecting a gate via squared-amplitude normalization

Wire

Uncommitted state / Pre-decision amplitude

State held in superposition; no external action taken

Disc

Committed record / Checkpointed state

State collapsed and persisted via fsync; action executed

the collapse

Measurement / Decision commit

Transition from wire to disc; the act of making a decision real

Spinor encoding

Phase-amplitude representation / Continuous encoding

Expanding scalar phi into (cos, sin) to recover lost information

Glyph

Residue-code address / Index

Integer 0..206 derived from phi; used for O(1) memory lookup

the prime ladder

Prime-indexed lookup table / Sigma mapping

207 primes mapped to glyphs; defines the address space

sigma locate

Address resolution / Hash mapping

Mapping phi to a glyph via fixed-point multiplication and modulo

Memory & Addressing

the hypercube

Boolean lattice / Hamming space

Q_n: vertices are n-bit integers; edges are single-bit flips

Gray walk

Hamiltonian cycle / Adjacent-bit traversal

Gray code: consecutive states differ by one bit; glitch-free addressing

Hamming distance

XOR popcount / Bitwise dissimilarity

Number of bit differences between two states; used for proximity

the cube

Spatial memory lattice / Content-addressable store

Memory organized by Hamming distance; related states are physically close

flat address space

Linear memory model / Virtual memory abstraction

The conventional model; NUMEN avoids it in favor of relational addressing

locality

Cache affinity / Memory clustering

Related states are stored in adjacent cache lines for speed

grounded

Cached / Resident / O(1) access

State is near the attractor; lookup is immediate

ungrounded

Uncached / Search-required / O(n) access

State is far from attractor; requires scanning the field

grounding

Caching / Memoization / Precomputation

The act of moving a symbol from search to O(1) lookup

the river

Memory hierarchy / Cache pipeline

The flow of addresses from ungrounded (slow) to grounded (fast

Learning & Meta-Control

Hebbian update

Success-based reinforcement / Reward modulation

Gate bias increases if it led to improved phi proximity

penalty

Failure-based decay / Negative reinforcement

Gate bias decreases slightly on stagnation; asymmetric learning

bias decay

Forgetting / Weight drift toward uniform

Slow pull toward uniform distribution to prevent monopoly

convergence rate

Learning progress / Success rate

Fraction of recent ticks that reduced error

apprentice

Meta-learner / Tool-selector optimizer

Tracks per-tool reliability and adapts selection policy

consolidation

Offline replay / Experience compression

Nightly phase that replays experience into persistent weights

experience replay

Replay buffer / Memory replay

Replaying past experiences to update weights

mastery

Threshold convergence / Success criterion

Error below epsilon for a sustained window

mastery-gated expansion

Gradual scaling / Stage-wise growth

Increase model capacity only after current stage is mastered

the school

Curriculum learning / Stage-wise training

The system's own training scheduler

Sensing & Input

echo signature

Behavioral biometric template / User embedding

Feature vector derived from keystroke timing, attention, circadian phase

rhythm band

Inter-event timing / Dwell-flight features

Keystroke dynamics: intervals and key hold times

attention band

Focus token / Salience hash

Hashed window/URL/file token; indicates current focus

circadian band

Diurnal phase / Time-of-day encoding

Wall-clock phase over 24h; the "when" of behavior

confidence

Template freshness / Liveness score

Decays with silence; rises with input; prevents stale identity

the WHO channel

User identity stream / Biometric channel

The exogenous input that identifies the user

the WHERE channel

Spatial location stream / Place-cell channel

Hippocampal L6 grid/place output; position in phi-space

two-oxygen architecture

Dual-channel sensor fusion / Exogenous+endogenous

Two independent input streams: internal jitter and external corpus

world-open

Externally coupled / Not sensor-bottlenecked

Predictive error exceeds sensor entropy; the model is fed by the world

feed

Ingestion / Corpus loading

Pushing external data into the prediction pipeline

Action & Execution

the hands

Effectuators / Tool-execution layer

The subsystem that invokes external commands via fork+exec

the verbs

Command surface / Allow-list

The ~40 CLI flags that constitute the system's action set

tool use

Function calling / External tool invocation

Executing pre-authorized commands and folding output back

the governor

Authorization layer / Safety monitor

Decoupled policy engine that evaluates intent before execution

autonomy level

LoA / Decision autonomy grading

Scale from advisory to high autonomy; gates execution rights

the fence

Guardrail / Pre-execution check

Prevents unsafe actions from reaching the executor

the ledger

Audit trail / Write-ahead log

Append-only fsync'd log of every committed action

efferent arc

Output pipeline / Action commit path

The path from decision to physical effect

enter

Commit / Execute / Apply

The act of crossing from wire to disc; the final action

mission control

Systems dashboard / Unified orchestration

Fuses all live organs into a single aggregated UI

the arsenal

Toolset / Command roster

The full collection of 26 runtime verbs

Governance & Safety

the immune system

Fault detection / Self-healing / Watchdog

System that monitors anomalies and applies corrective treatments

9-step protocol

Anomaly handling pipeline / Remediation cascade

Detect → propagate → isolate → prescribe → consent → treat → verify → release → immunize

anomaly

Control error / Stability violation

Phi stagnation, CI freeze/fever, gate imbalance

treatment

Remediation action / Error correction

Phi kick, CI adjustment, gate rebalance

WHY-disc

Rationale record / Explanation artifact

A written record explaining why a treatment was applied

immunize

Long-term fix / Permanent corrective update

Compounding a cure if anomaly recurs

the nerve

Signal handler / Interrupt response

SIGSEGV/SIGALRM handlers; memory guards, timing analysis

CRC32 anchor

State integrity hash / Tamper-evident seal

Hardware-accelerated checksum of critical state

honeypot phi

Decoy value / Misdirection

Serving phi^-1 instead of real target to probes

threat level

Risk index / Security posture

0..1; gates defense layer activation

Persistence & Logging

the disc

Immutable record / Provenance artifact

Write-once, sealed file with checksum

the seal

Integrity checksum / Tamper-evident hash

FNV-1a hash over canonicalized record fields

the dish

Persistent storage directory / Archive

Directory where discs are written; the "petri dish" of records

crystallization

Checkpoint flush / Sync to durable storage

Writing a record and calling fsync to guarantee persistence

the sanctuary

Trusted boundary / Reference monitor

The membrane between description (wire) and physics (disc

the membrane

Write barrier / Commit boundary

The single crossing point where intent becomes effect

rolling key

Challenge-response nonce / Liveness token

KDF(secret, epoch) || jitter; proves fresh key generation

checkpoint

State snapshot / Persistent restore point

The exact Q32.32 state saved for power-cycle recovery

Agents & Services

THE FIVE

Five functional executors / Modular services

Oracle, Architect, Conductor, Translator, Healer

Oracle

Forecaster / Predictor

Runs IIR filter ahead; generates predictions

Architect

Builder / Universe generator

Constructs simulations and code from specifications

Conductor

Scheduler / Orchestrator

Manages the tick loop and dispatches work

Translator

Serializer / Format converter

Maps internal state to JSON; handles quantization

Healer

Watchdog / Fault handler

Monitors stability; applies corrective treatments

swarm

Population of agents / Multi-agent system

Multiple independent controllers sharing a consensus centroid

vdb

Vector database / Embedding store

O(1) phi-indexed storage, no HNSW, pure CPU

quat-vm

GTAC interpreter / Bytecode runner

Executes any file as a GTAC-threaded program

brain

Bilateral state machine / Two-brain governance

Left=deterministic, right=quantum; disagreement escalates to user

map

Cartographer / Data lineage tracker

Connects models to source files; queues for architect

world

Realm renderer / Live visualization

SNES+GPU renderer fed by world.json

sapience

Autonomous documentation / Self-writing engine

The FIVE read, learn, execute, and document themselves

Observability

observatory

Telemetry dashboard / Live monitor

WebSocket (port 8081) streaming live state at 85Hz

live_state.json

Telemetry snapshot / State dump

Per-tick JSON file with phi, gate, fitness, etc.

the microscope

Diagnostic probe / State inspection tool

Magnifies phi to reveal fine structure; used for healing

the collider

Profiling instrumentation / Performance tracer

Measures time (ns) and accuracy (deflection) of each pipeline stage

the echo sensor

User biometric front-end / Feature extractor

Extracts rhythm, attention, circadian from user events

the health monitor

System health check / Liveness probe

Reports organ health, coherence, anomaly count

the manifest

Index / Master record

JSON describing the current system state, organs, and artifacts

Performance Metrics

coherence

Control convergence / Population consensus

1 - |mean_phi - S| / tolerance; 1 = fully converged

H_pred

Predictive entropy / Surprise magnitude

Information content of prediction error; bits

DPI ladder

Data-processing inequality cascade / Information loss chain

H_jitter → H_phi → H_gate; decreasing entropy

consensus variance

Population variance / Average convergence

Variance drops as 1/N for N coupled agents

grounding cost

Access latency / Memory hierarchy cost

Grounded ~2ns, ungrounded ~2000ns

Q-Quantization retention

Information retention / Quantization loss

2-bit encoding keeps ~10% of predictive info

spinor recovery

Continuous encoding gain / Phase recovery

Spinor recovers ~88% of lost info

FPS

Tick rate / Frame rate

85Hz nominal; measured via RDTSC

CPU core

Physical execution core / Bare-metal substrate

The x86-64 core the system runs on

Honest Limitations

virtualized entropy degradation

Hypervisor TSC quantization

TSC reads are trapped; jitter reduced; performance claims host-dependent

practical uniqueness

Non-cryptographic identity / Low entropy space

Template space is 4^5=1024; collisions expected near ~32 users

FNV-1a

Fast non-cryptographic hash / Tamper-evident only

Not a MAC; not collision-resistant; use sha256sum for crypto

marginal entropy proxy

Approximate DPI / Directional indicator

Full mutual information not computed; use with caution

saturation ceiling

Quantizer bottleneck / Resolution limit

H_pred saturates at ~4.5 bits; requires per-token vector to lift

allow-list

Curated tool set / Limited action space

Only 4 primary tools; not general code execution

read-only telemetry

Observability only / No command broker

WS-8081 is receive-only; no remote injection yet

setpoint arbitrary

Fixed point chosen, not discovered

S could be any value in (0,1); convergence holds for all

single-threaded

Deterministic but not parallel

Single core; future multi-node support requires consensus extension

Ring-3 execution

Userspace, not kernel

Runs as a userspace process; not a kernel module or SMM firmware

Where it breaks

A translation page that only translated the good parts would be marketing. These are the load-bearing caveats, stated the same way they are stated internally.

The setpoint is arbitrary. φ⁻¹ was chosen, not discovered — convergence holds for any target in (0,1).
Entropy claims are host-dependent. Under a hypervisor the TSC is trapped and the jitter degrades.
The quantizer saturates around 4.5 bits of predictive entropy. Lifting that ceiling needs a per-token vector, which does not exist yet.
Identity templates live in a 4⁵ = 1024 space. Collisions are expected near ~32 users. This is not cryptographic identity.
FNV-1a is tamper-evident, not collision-resistant. Do not call it a MAC.
The core is single-threaded, userspace, one core. Not a kernel module, not parallel, not distributed.
The action set is a curated allow-list. It is not general code execution.
The rollout planner is greedy at depth one. It wedges on levels that need a multi-step plan, and it stays wedged.

Watch it run

The Arcade

The rollout planner playing real games, with the reels, the scores and the levels it gets stuck on.

Open the arcade Look at the rest

The Gallery

Every render, chart and telemetry capture the machine has produced — the full set the art above came from.

Open the gallery

Discrete time stepNUMEN calls it: the tick

Hardware timing-jitter entropyNUMEN calls it: the jitter

Scalar control variableNUMEN calls it: System State (phi)

First-order IIR feedback controllerNUMEN calls it: the one law

2-bit scalar quantizerNUMEN calls it: GTAC gates

Uncommitted state vs. checkpointed recordNUMEN calls it: wire and disc

Hamming-space content-addressable storeNUMEN calls it: the cube

Prime-indexed lookup tableNUMEN calls it: the prime ladder

Meta-control / hyperparameter schedulingNUMEN calls it: learn-to-learn

Effectuator / tool-execution layerNUMEN calls it: the hands

Telemetry dashboardNUMEN calls it: the observatory

Save-state rollout plannerNUMEN calls it: the Oracle