A 230,000-Parameter World Model That Taught Itself to Win

Fourteen times, an agent of ours has been dropped into a video game it had never seen, with no instructions, no manual, and no idea which button does what — and finished a level.

The fastest one took fourteen actions.

The thing doing the predicting is a world model with 0.23 million parameters. Not billion. Million. About a megabyte of weights, small enough to email.

Here is what that looks like:

The record

Every level completion, oldest to newest:

Four in July. Ten in the first nine days of August. The three fastest solves — actions 14, 18 and 19 — are not early flukes; they are what happens once the agent stops rediscovering the controls every time.

What "no instructions" actually means

ARC-AGI-3 is not the grid puzzles most people mean by ARC. It is a set of small interactive games. You get a 64x64 board of coloured cells and a handful of actions. Nothing tells you what the actions do. Nothing tells you what winning looks like. You press things and watch what changes.

So the first job is not strategy, it is proprioception: which button is "up"? Our agent spends its opening moves probing one control at a time and writing down what moved. That is why a solve at action 14 is remarkable — it means the agent had already learned that game's controls on a previous run and started the level knowing them.

That memory is real and durable. Across all play the agent has written 345 durable facts about these games. One of them reads:

ls20 controls MEASURED control map (probed one control at a time): ACTION1->up, ACTION2->down, ...

It was read back 752 times.

The efficiency, which is the actual story

Here is the arithmetic that made us stop and re-measure, because it looked wrong:

Roughly 650x smaller. The checkpoints range from 0.11M to 0.23M parameters depending on the training regime. The files on disk are ~180 MB, which fooled us for a while — but that is almost entirely the replay buffer riding along inside the checkpoint. The weights themselves are about a megabyte.

Thirty of these models stacked together would still be a fifth the size of one frontier reasoning model. We know, because we ran thirty of them.

And it was not trained on a dataset. There is no labelled corpus of "correct ARC-AGI-3 play" — it does not exist. The model has 421,000 training steps, every one of them generated by the agent playing, mostly losing, and predicting what the screen would do next. It taught itself the physics of each game by being wrong a lot, cheaply.

That is the part worth sitting with. The expensive ingredient in most agents is the model. Here the expensive ingredient was time on the game, and the model is a rounding error.

The stack underneath it

The world model is a megabyte, but it is a megabyte sitting on top of a lot of machinery. Nothing here is one model doing one thing — it is a layered perception stack, 57 modules, where each layer hands the next one something cleaner than it received.

Layer 0 — deterministic senses. Before any learning happens, ordinary code looks at the screen. It tracks objects across frames by colour-invariant identity, so a thing that changes colour is still the same thing. It computes a spatial digest of the board and a signed distance-to-goal. This layer has no weights and cannot be wrong in an interesting way — that is the point. It is the floor everything else stands on.

Layer 1 — memo and filter. An exact-match memory of "I have seen this board and pressed this button before, and here is what happened," plus a small logistic model that re-ranks candidate actions by probability of having any effect. Enormously cheap, and it kills the single most wasteful failure mode: pressing buttons that do nothing, over and over.

Layer 2 — proxy reward. The games do not tell you that you are getting warmer. So the distance-to-goal delta from Layer 0 becomes a shaped reward that search can actually climb. This is what turns a random walk into a search.

Layer 3 — learned dynamics. This is the world model: an encoder that maps a grid to a latent vector, and a predictor that takes that latent plus an action and predicts the next latent. Plan in latent space, compare the prediction to what actually happened, and the gap is surprise — a signal for where the model's understanding is thin.

The elegant part is that Layer 3 trains for free. Layers 0–2 already produce, on every single turn, exactly the tuple a world model needs: previous grid, action taken, resulting grid, reward delta. The senses that ship today emit a training batch as a side effect of playing. Nobody has to build a dataset, because the act of playing is the dataset.

On top of that sits Monte Carlo tree search using the world model to roll futures forward, a council that weighs competing action proposals, and a persistent memory that survives the run — which is why a solve at action 14 is possible at all.

The models are ours and they are local

Every language-model call in this system goes through one internal scheduler rather than straight out to an API. That indirection is the whole reason the stack is swappable — the solver asks for a capability, not a vendor.

Behind it are our own lanes, running on our own hardware: gemma4-12b as the primary reasoner, deepseek-flash-v4 for the heavier reasoning passes, bonsai as the small fast model (small enough that a version of it runs in a browser tab on WebGPU), and an orchestrator that routes between them. They are spread across a mesh — a 32 GB consumer GPU on one side, a 128 GB unified-memory box on the other — so model placement is a scheduling problem across the mesh rather than a fight over one card's VRAM.

Which means the whole loop that produced those fourteen wins ran on hardware we own, with models we serve. The only thing rented was time.

What it costs to think

Median time per action: 7.4 seconds. Ninetieth percentile: 72.5 seconds.

That number is the binding constraint on everything above, and it is worth being blunt about why. Most of that time is not the world model — a 0.23M-parameter forward pass is microseconds. It is the language model that narrates each move. The agent currently asks a large model what to do, every turn.

Which means the ceiling is not intelligence, it is budget. Runs are capped because they have to be, and a capped run cannot go deep into a level it has not already learned. Several of the wins above came in at 191, 137 and 111 actions — right up against the cap. We do not know how many near-misses were simply runs that ran out of turns.

The obvious move is to invert it: let the tiny model decide the ordinary moves, and spend the expensive model only where the cheap one is uncertain. We have measured the ingredients for that and they are promising and not yet good enough — our best change-predictor gets about 10% of changed cells right, which is a usable uncertainty signal and not yet a usable policy.

What we can prove, and what we can't yet

Everything above is measured from our own logs. You should discount it until somebody other than us can confirm it, so here is exactly where that stands.

The runs go against ARC Prize's real API, in online mode — their games, their server, and a scorecard opened per run. We hold 440 scorecard ids. We have verified, live, that opening one really does reach their API and return a real id.

What we have not managed is to read one back. Their scorecard read endpoint answers 404 for our ids — and, tellingly, it also answers 404 for a brand-new scorecard we opened successfully seconds earlier. So the 404 is not evidence that our scorecards are missing; it is evidence that we do not yet understand the retrieval path. Nor is the friendly-looking web page: that URL returns HTTP 200 for any id at all, because it is a client-rendered shell. Two signals, both useless in opposite directions.

We are not publishing scorecard links until we can open one, close it, and read it back with the numbers intact. Claiming third-party verification we have not actually performed would be worse than having none. When that works, the links go here and you can check the arithmetic yourself.

The honest scoreboard

Fourteen completions out of 661 scored runs is 2.12%. Best level ever reached: 1.

We are publishing that number on the front of the site next to the GPU and model counters, deliberately. A dashboard that can only go up is not a measurement. If the rate climbs, the climb should be legible; if it stalls, that should be legible too.

The uncomfortable part

The first level completion happened on 11 July. We found out on 16 August.

Not because anything crashed — because nothing was watching for success. The health check on the solver asks one question: was a recording written in the last ninety minutes? A win and a loss produce identical answers to that question. Every other alarm in our platform fires on failure. There was no code path anywhere that could report a good thing happening.

So the machine quietly did the most interesting thing it has ever done, fourteen times, into a log file, for five weeks.

That is fixed now — a solve pages a phone within hours, and the full solve log ships with the site. But the lesson generalises past us: if you only instrument failure, you will be the last to know when your system starts working.

What is next

Three things, in order of how much we think they matter:

1. Make thinking cheap. Move the default move-by-move policy onto the world model and reserve the language model for genuine uncertainty. This is the one that unlocks deep runs.
2. Carry memory harder. The agent has 345 facts, but 320 of them are about a single game. Learning transfers within a game beautifully and between games barely at all.
3. Level 2. Everything above is level 1. Nothing has yet finished a second level, and we do not yet know whether that is a depth problem or a different problem.

A megabyte of self-taught weights, fourteen actions, no instructions. We will take it.