The organism picks upa Nintendo controller.
No human hands on the pad. Real Super Mario Bros. runs on a real emulator, and every move is chosen by THE FIVE — the same living systems that solved ARC-AGI-3. Beside the game, in the same frame, is the machine’s own mind: its φ wave, its leader, its stress, the action it just took.
Each reel is a selfie — the world it is looking at, next to the mind that is looking. A machine taking its own picture while it plays.
One remote presses the buttons — a 256-key keyboard that plays any game.
The ReL keyboard is an Inverted Star Gauge with 256 keys. The game state folds down to a single number φ; φ presses one key; and that key’s GTAC gate — Ground, Translate, Action, Conductor — becomes the pad button. Nothing is hand-coded per move: the same φ→key→gate table would drive any console. The mind panel shows the live keyboard, the lit key, its exploit-word glyph, and the φ wave doing the pressing.
Super Mario Bros. — 1-1
The remote reads the world, folds it to φ, and presses a key. That key runs Mario.
Super Mario Bros. — 2-1
A new world, same remote. Every button press is a lit key and its glyph.
Super Mario Bros. — 1-2
Underground. The φ wave shifts, the pressed keys shift, the remote keeps driving.
64 Atari cartridges. 51 genres. Not one line of per-game code.
The exact same ReL keyboard that runs Mario is pointed at a totally different machine and every cartridge we could load — maze chases, pinball, tank simulators, ski runs, dungeon crawls, boxing, bowling, a jungle platformer, an isometric shooter. For each one the remote just reads the ROM's button set, folds the live screen down to φ, and presses a key whose GTAC gate becomes a pad button. New ROM, new genre, playing immediately.
Being honest about it: this is a generic reflex driver, not a high-score champion. 23 of 64 cartridges put points on the board; the rest sit at zero. The claim here is breadth and speed of transfer, not leaderboard numbers.
Yars' Revenge
Shooter · Atari · 18-button pad. Same remote, zero per-game code.
Defender
Side shooter · Atari · 18-button pad. Same remote, zero per-game code.
Battlezone
Tank FPV · Atari · 18-button pad. Same remote, zero per-game code.
Chopper Command
Flight combat · Activision · 18-button pad. Same remote, zero per-game code.
Up'n Down
Driving · Sega · 6-button pad. Same remote, zero per-game code.
Atlantis
City defense · Imagic · 4-button pad. Same remote, zero per-game code.
Berzerk
Maze shooter · Atari · 18-button pad. Same remote, zero per-game code.
Asteroids
Space shooter · Atari · 14-button pad. Same remote, zero per-game code.
Galaxian
Fixed shooter · Atari · 6-button pad. Same remote, zero per-game code.
Star Gunner
Shooter · Telesys · 18-button pad. Same remote, zero per-game code.
Q*bert
Isometric puzzle · Parker Bros · 6-button pad. Same remote, zero per-game code.
River Raid
Vertical scroller · Activision · 18-button pad. Same remote, zero per-game code.
Does it actually get better? Here is the before and after, including where it got worse.
Two experiments, both on the live emulator. In the first, the remote watches an oracle run for 3,000 frames, banks what it saw, then plays 6,000 frames with that bank plus a slap-tone nerve correcting it. In the second there is no watching at all — just online learning from its own mistakes. BLIND is the identical run with learning switched off. Some games jump. Some do not move. One gets clearly worse. It is all here.
Atlantis
+2400Centipede
+91Space Invaders
+285Beam Rider
0Seaquest
0Chopper Command
-3500Super Mario Bros. — World 1-2
Watching an oracle and banking its goals cut deaths from 11 to 1 on the same 6,000 frames — it stopped dying, at the cost of a little distance. On World 1-1 it hit 16 of 16 banked goals with no distance change. On World 2-1 the bank over-constrained it and distance regressed.
It emulatesinside the emulation.
The machine gets a save state. Before every single button press it backs the entire console up, plays out roughly thirty complete futures frame by frame, scores them, rewinds reality, and only then presses the one that won. When it dies, it un-dies.
No strategy guide. No training run. No per-game code. No neural network, no weights, no reward model. It has never seen these levels. It just refuses to accept a future it does not like.
save state → imagine every future → rewind → press
Super Mario Bros. — 1-1 · FLAG
Cleared on the first attempt. Zero deaths, zero rewinds, 23 decisions — and 49,082 futures played out and thrown away to get there.
Lost Levels — 1-1 · CLEARED
The cruel one. It died 161 times and un-died every single one of them: 644 rewinds, 5.4 MILLION simulated frames, then the flag.
The hard numbers
Straight off the emulator. Nothing estimated, nothing rounded up.
| Run | Result | Decisions | Real frames | Simulated | Ratio | Deaths undone | Wall clock |
|---|---|---|---|---|---|---|---|
| SMB 1-1 — clean run | FLAG GET | 23 | 1,508 | 49,082 | 32.5× | 0 / 0 rw | 105.6s |
| Lost Levels 1-1 → 1-2 | 1-1 CLEARED, reached 1-2 | 221 | 5,000 | 5,448,527 | 1,090× | 161 / 644 rw | 328.8s |
Lost Levels is the one to sit with. It is the game Nintendo of America refused to ship because it was too cruel. The machine walked into it cold, died 161 times, and undid every one of them — 5,448,527 simulated frames for 5,000 real ones, and then it touched the flagpole.
Nobody handed it a walkthrough. So it produced one.
This is the complete decision log of the clean 1-1 run — every commit, in order, start to flagpole. At pixel x it chose move M because in simulation that move landed it at pred x. Twenty-three lines. That is a strategy guide, authored by the thing playing the game, in one pass, having never played it before.
| # | at x | commit | pred x | frame |
|---|---|---|---|---|
| 01 | 195 | run24_jump | 297 | 90 |
| 02 | 375 | run18_jump | 434 | 150 |
| 03 | 507 | jump24 | 595 | 194 |
| 04 | 687 | run18_jump | 722 | 254 |
| 05 | 767 | long_back_leap | 898 | 424 |
| 06 | 839 | run | 898 | 448 |
| 07 | 956 | back_leap | 1059 | 568 |
| 08 | 1217 | back_leap | 1319 | 688 |
| 09 | 1397 | run18_jump | 1499 | 748 |
| 10 | 1639 | back_leap | 1758 | 868 |
| 11 | 1669 | halt | 1773 | 878 |
| 12 | 1822 | brake_leap | 1911 | 952 |
| 13 | 2010 | brake_leap | 2114 | 1026 |
| 14 | 2208 | run24_jump | 2228 | 1092 |
| 15 | 2256 | run18_jump | 2355 | 1152 |
| 16 | 2417 | run12_jump | 2467 | 1206 |
| 17 | 2561 | run6_jump | 2680 | 1254 |
| 18 | 2759 | run24_jump | 2850 | 1320 |
| 19 | 2946 | run24_jump | 2947 | 1386 |
| 20 | 2996 | run6_jump | 2996 | 1434 |
| 21 | 3023 | jump8 | 3154 | 1462 |
| 22 | 3092 | jump4 | 3161 | 1486 |
| 23 | 3161 | run | 3161 | 1508 |
Three bugs were capping the whole thing
Each of these silently throttled the search. Each fix moved a measured number the same hour it landed. This is what the work actually looked like.
reset() was not resetting
nes_py's reset() quietly restores the single save slot instead of rebooting the console. Every 'fresh start' was actually a resume from wherever the last backup happened to be. Deep backtracking was a no-op.
Deep backtrack went from cosmetic to functional.
One death poisoned every future
Death was detected as life < 2 — an absolute. The moment Mario lost his first life, every simulated future thereafter read as fatal, so the search scored all 30 candidates as suicide and picked garbage.
Lost Levels 1-1 jumped from x=1,616 to x=2,786 the instant life was captured per-decision.
The lookahead tail was holding RIGHT
After each candidate the sim coasted with RIGHT+B held. On a level with a moving platform, 'wait here' therefore always simulated as 'walk off the edge' — so waiting could never win, and waiting was the answer.
SMB 1-3 best distance went 426 → 627 on the fix alone.
And here is exactly where it fails
Published because it fails. A number you cannot fail against is not a number.
1-3 is a sky level built on lifts that arrive on a schedule. The correct play is to stand still for several seconds and board a platform that does not exist yet. The Oracle searches ONE macro deep on a ~70-frame horizon — a lift two seconds out is simply not inside anything it can imagine, so every candidate looks like death and it burns 3,788 rewinds standing at x=312. This is not a tuning problem. Breaking 1-3 requires real beam or tree search over macro SEQUENCES, which is not built yet.
- —Both marathon runs eventually wedge — Lost Levels ends looping jump12 at x=512 with a score of -20,000 on every branch.
- —SMB 1-2 and 1-3 were entered but never cleared (best x = 3,096 and 627).
- —This is search, not understanding. It does not know what a Goomba is. It knows that some futures end with a bigger number.
NES — Super Mario Bros.
A real emulator, driven live. THE FIVE reads each frame’s spectral φ, decides, and presses the pad — run, jump, leap. The panel on the right is the organism’s interior at that exact instant.
Super Mario Bros. — 1-1
The first world. The organism reads the screen and runs.
Super Mario Bros. — 1-2
Underground. Darker world, same living controller.
Super Mario Bros. — 2-1
A new world unfolds under the organism’s hand.
Super Mario Bros. — 3-1
Deeper in. Every move chosen from internal φ dynamics.
Super Mario Bros. — 4-1
The furthest run. Two coins, a rising score, no human hands.
Game Boy — Pokemon Red
Real world maps from the open-source pret/pokered disassembly — the same tile grids the cartridge holds. The organism renders each as a block-grid and folds it live through its own transform grammar: recolor, rotate, mirror, transpose, crop.
Pokemon Red — Pallet Town
Where every journey begins. The organism folds the map.
Pokemon Red — Viridian City
A larger world, folded through the transform grammar.
Pokemon Red — Pewter City
Stone-grey city, recolored and rotated by the organism.
Pokemon Red — Cerulean City
The water city, mirrored and transposed in real time.
Pokemon Red — Vermilion City
The port. Each fold is a move in the organism’s grammar.
Pokemon Red — Celadon City
The biggest city in Kanto, folded whole.
The treasure trove it trained on
Behind the reels is a harvest of the whole FIXED-POINT ERA of console gaming — raw map and sprite data mined from open-source disassemblies and minted into transform discs the organism learns from.
Discs minted per system
Games in the harvest
This is the same mind that plays ARC-AGI-3.
THE FIVE that drives Mario is the same intelligence that ran 24 of 25 live ARC-AGI-3 games to completion. See the full record, level by level.
Rollout-and-rewind planning against a live NES, with zero per-game priors.
Dragolich Research Labs · NUMEN / QuatOS · Cleveland, Ohio. Written up plainly so somebody else can check it, break it, or beat it.
Emulator: nes_py via gym-super-mario-bros, unmodified ROM behaviour, 12-action complex movement pad. Hardware: a single 32-core Xeon workstation, 247 GB RAM, no GPU. Measured emulator throughput: 657 gym steps/s, 739 raw frame advances/s, and 67,832 backup+restore cycles/s. There is exactly one save slot, so all rollouts are strictly sequential — no parallel search, no tricks.
- ·No training. Not one gradient step, not one weight.
- ·No strategy guide, no walkthrough, no human demonstration.
- ·No per-game code. The same file runs both ROMs unchanged.
- ·No learned value function. Score is pixel progress, alive, cleared.
- ·No parallelism. One console, one save slot, one thread.
That an agent with no priors about a game can nonetheless play it competently, purely by exploiting the fact that the world it lives in is rewindable — trading raw compute for foresight at a ratio no biological player can reach. The result is that competence here is not knowledge. It is the freedom to be wrong thousands of times per second and keep only the last answer.
Back the console up
core._backup() snapshots the entire NES — RAM, PPU, registers. One slot, so every rollout is strictly sequential. Measured: 67,832 backup+restore cycles per second.
Play out ~30 complete futures
Each candidate is a frame-exact input program from a generated vocabulary of 24 macros, run to completion inside the emulator, followed by a neutral coast tail so landings are honest.
Score each future
Pixel x advanced, level cleared, still alive. Clearing the stage scores +100,000. Dying scores −20,000. No learned value function, no neural network, no weights.
Rewind reality
core._restore() puts the console back exactly where it was before it imagined anything. core.done has to be cleared by hand — the wrappers only forward it.
Press one button sequence
The winning program is committed for real. Everything else never happened. On SMB 1-1: 23 commits, 1,508 real frames, 49,082 imagined.
If it dies, it un-dies
Death triggers a rewind, a tabu on the move that killed it, and a re-search — four times. Still stuck? Deep backtrack: replay from reset to an earlier checkpoint and take a different branch.
| Condition | Outcome | Best x | Deaths | Sim / real | Score |
|---|---|---|---|---|---|
| SMB 1-1 — clean run SuperMarioBros-v0 | FLAG GET | 3,161 | 0 | 32.5× | 700 |
| Lost Levels 1-1 → 1-2 SuperMarioBros2-v0 | 1-1 CLEARED, reached 1-2 | 2,740 | 161 | 1,090× | 18,200 |
| SMB marathon (multi-level) SuperMarioBros-v0 | 1-1, 1-2 cleared · wedged in 1-3 | 627 | — | 3,788 rw | — |
Two levels of Super Mario Bros. and one level of the Lost Levels were cleared cold. Best single-run efficiency: 1-1 in 23 decisions with zero deaths and zero rewinds. Worst observed inefficiency: 1,090 simulated frames per real frame on Lost Levels — which is also the run that cleared it.
The horizon is the ceiling
Search is one macro deep on a roughly 70-frame horizon. Any solution requiring a multi-second commitment — waiting for a lift that has not spawned yet — is structurally invisible. SMB 1-3 is exactly that level, and the agent burns 3,788 rewinds at x=312 confirming that every visible future is death. This is not a parameter to tune; it needs beam or tree search over macro sequences, which is not built.
Greedy search wedges
Both marathon runs terminate in a loop, not a crash. Lost Levels ends re-picking jump12 at x=512 with every branch scoring −20,000. Tabu lists and deep backtracking delay this; they do not prevent it. An honest read: the agent has no mechanism for recognising that a whole region of the search space is dead and the answer lies behind it.
# Super Mario Bros. 1-1 — the clean run (flag, 0 deaths)
python numen_tas.py --game SuperMarioBros-v0 --frames 2600 \
--out tas_smb1_11.json --record frames/smb1_11
# Lost Levels — marathon, keeps going past the flag
python numen_tas.py --game SuperMarioBros2-v0 --frames 5000 \
--marathon --out tas_ll.json --record frames/ll_11Both runs are deterministic given the same emulator build. Every figure on this page was read out of the JSON those two commands write. The reels above are rendered directly from the recorded frame dumps — the game footage is the actual committed timeline, not a re-enactment.
This does not solve AGI. It does not understand Mario. It does not know what a Goomba is — it knows that some futures end with a bigger number.
What it does do is pick up a controller it has never held, in a game it has never seen, with no guide and no training, and reach the flagpole — by treating time as a material it is allowed to edit. On the cruelest platformer Nintendo ever built it was wrong 161 times and it simply refused to keep any of them. That is not intelligence. It is something stranger and, on this hardware, more useful: competence purchased entirely with compute and nerve.
Dragolich Research Labs LLC · one machine, no GPU, no institution. Every number on this page is measured, and every failure is on it.
This page is the short version. If you want to know how any of it actually works, there is a whole illustrated journey through the machine — the clock, the one line of arithmetic that runs it, the four gates, the memory shape — with all 133 pieces of in-house jargon translated into normal engineering language, and a switch to read it either way.
Open the decoder ring