A tiny model that teaches itself to run a warehouse

Dean Chugall — Tue, 10 Nov 2026 15:52:59 +0000

A 5.7-million-parameter hCAWN model, small enough to run on a plain CPU, learns to run a grid warehouse from its own results, with no teacher and no labels, and you can watch it improve live at wh.cawnai.com.

The task is simple to state: pick up boxes, bring them to the dock and never let the battery run out. The model sees a short line of text about what is around the robot and answers with one move. Nobody tells it the right move. It keeps what worked, throws away what did not, trains on that, and tries again.

How small is that? The model has 5.74 million parameters, 6 layers of width 128 (two of them attention, the other four CAWN layers), and reads and writes raw bytes instead of a word vocabulary. Its int8 weights take about 6 MB, and 3.9 MB packed to int4. Nothing here needs a GPU to run; only training does.

The live page: forty copies of the model work the same warehouse. The striped cell is the dock, the lightning cells are chargers, and the big shelves are walls.

Learning only from what really happened

Most small models are taught by imitation: a bigger model or a human writes the right answer and the small one copies it. Here there is no such answer key. The only teacher is the world: a delivery either happened or it did not.

That is what recursive self-improvement (RSI) means in this demo. The model produces its own training data, the world filters it by outcome, and the filtered data trains the next version of the model. Each version is a better data generator for the one after it, so the loop can keep going instead of stopping at a fixed ceiling.

How the loop works

Every generation is the same five steps. Forty copies of the current model each try to deliver boxes on their own, with some random moves so they explore. Only paths that ended in a real delivery are kept as lessons, and loops inside them are cut out. The model is trained on those lessons and becomes the next generation. Then one robot, with no randomness, works alone and is scored against a perfect shortest-path robot on the same warehouse.

The filter is the only teacher: a path counts only if it ended in a delivery.

The solo test: one robot with the model alone, no random moves. It searches for a box, delivers it to the dock and goes on until its battery runs out or the time is up.

The score is the percentage of the perfect robot's deliveries, averaged over three runs with different box placements, because a single run is too noisy.

In symbols, training is ordinary next-move learning, but only on paths that were successful:

L (θ) = - E τ \sim π θ [1 [delivered (τ)] t \sum lo g π_{θ} (a_{t} ∣ o_{t})]

and the score of a generation is how close it gets to the perfect robot:

accuracy = \frac{D model}{D perfect} \times 100%

Here $o$ is what the robot sees, $a$ its move, and $D$ the number of deliveries in a 400-step run.

What is hand-written and what the model learns

The model learns the hard part: the way to the box and to the dock, around walls and out of dead ends. It sees one line of text, with its own cell, the compass direction to its goal, a 5x5 window of walls and cells it has already walked on, and its last move.

The easy part is hand-written on purpose: a charging reflex. A robot that carries a box cannot charge, and the reflex only takes over when it has no box in its hands.

That reflex taught me the most. The first version turned back to a charger when the battery fell to about 16 steps from one, so far boxes were never reached and every run ended with a dead battery after one charge. The fix is a different rule. The robot goes to charge only when its battery is lower than the real cost of the next delivery: the way to the box, the way with it to the dock, and the way from the dock to the nearest charger, with a pessimistic reserve for a box standing right next to the charger. If one battery cannot do the job at all, the robot first fills up at the charger from which it can.

In one line, the robot goes to charge when its battery $b$ cannot cover the next delivery:

charge ⟺ b < d (p, x) + d (x, dock) + d^{+} (dock, charger) + m

Here $p$ is the robot, $x$ the box, $d$ the walking distance, $d^{+}$ the pessimistic distance to the charger when the next box blocks the best way, and $m$ a safety margin of 4 steps.

On a test of 36 tasks the perfect robot made about a third more deliveries with the new rule (13.9 against 10.3 per run at the larger radii) and did not run out of battery once.

The swarm that produces the lessons has no battery at all, so none of its steps are spent on charging. Reflex steps never become lessons: the model is only taught what the model has to do.

Not going backwards

A self-improving loop can also self-destruct: one bad training run can make the next generation worse, and its data poisons the one after. Two rules guard against that.

A warehouse is learned only when it passes three generations in a row. Passing means at least 70% of the perfect robot on the last three tests, so one lucky run does not count.
The best model is always remembered. If a new generation scores clearly below the best one (15 points or more), it is thrown away, together with the lessons that made it. The learner goes back to the best model, collects fresh lessons with it, and trains the next generation from there.

The page shows this while it happens: a screen says which generation was worse, what it scored, which one is the best, and what the learner is doing now.

Why a tiny model, and what this does not prove

The model is an hCAWN, small enough to run on a CPU, and training it again for a new warehouse is cheap. Every learned warehouse keeps its own saved model, and a new layout starts from a blank one. That is the point of the demo: a small model that is retrained from outcomes on the exact environment where it will work, instead of a large general model that never saw it.

The architecture comes from my paper CAWN: Continuous Acoustic Wave Networks for Autoregressive Language Modeling (Čugalj and Jevremovic, arXiv, April 2026). Instead of attention over every earlier token, CAWN mixes the sequence with a causal, linear-time phase accumulation over complex-domain phasors and carries a constant-size state between chunks, so memory does not grow with the length of the context. The model in this demo, hCAWN, is a hybrid of that design with two attention layers. Only the architecture is taken from the paper; its evaluation is not used here.

It is also a limited demonstration. One robot in a grid warehouse is a problem where a classic shortest-path program already gives the perfect answer, and that program is only used as the yardstick, never for training. So the demo shows that the loop works and keeps improving. It does not show that the model beats a good algorithm. That needs a problem where no cheap perfect solver exists, which is where I want to go next.

Try it

Open wh.cawnai.com, watch the swarm work, and follow the generations improve in the big green number: the share of what the perfect robot delivers. You can also read more at cawnai.com.

Next I want to take the same loop to a problem where a program cannot simply give the perfect answer, and where the outcome can still be measured automatically.