Same wall, new fix — the AI broke its plateau by thinking harder, not getting bigger — Wintersalmon

The same wall, a completely different fix

Last time, the YINSH AI had stopped improving and the answer was a bigger brain: I doubled the size of the neural network and it beat the old champion, crowning a new one called gen-202. Then gen-202 plateaued too. The reflex was to reach for the same fix — make the network bigger again. That would have been the wrong move. This wall had a different cause: the AI wasn’t learning from good enough examples. The fix was to make it think harder — search more deeply — before turning each game into a lesson. It worked, and it taught me something about how a student can beat its own teacher.

TL;DR

gen-202 (the bigger network from last time) stopped improving — a new plateau.
Instead of a bigger network, I made the AI search twice as deep when generating its own practice games (about 400 → 800 “look-aheads” per move).
Result: two more promotions, a new champion gen-205, with its win rate against a neutral baseline climbing 0.70 → 0.75 → 0.81.
The catch: deeper search should have halved the training speed. The obvious fix — more parallel workers — did nothing. The real bottleneck was somewhere else, and one small change recovered full speed.
An 18-hour run is going even deeper right now to find out how far the trick goes.

How the AI learns, and why “deeper” matters

A quick recap of the loop. The AI plays games against itself; a fresh network is then trained to copy those games; and a strict statistical referee — a “gate” — only crowns the new network as champion if it provably wins more. That referee was never touched in any of this work, so every “promotion” means a real, measured improvement, not luck.

The important detail is how the AI picks each move while playing itself. It doesn’t just trust its gut. Before every move it runs a search: it imagines many possible continuations, looks ahead, and plays the move that holds up best. That searched move is stronger than the network’s instant instinct — and that gap is exactly what the network learns from. So the quality of the lessons depends entirely on how deeply the AI searched. Shallow search produces mediocre lessons, and a student can only ever match a shallow teacher.

A student can beat its teacher — if the teacher thinks deeper

Here is the idea worth keeping. The champion gen-202 generated its training games using a certain amount of search. A new network trained on those games could imitate gen-202 — but only up to gen-202’s level. You can’t out-learn a teacher by copying it.

So I let the teacher think deeper than it normally plays: double the look-aheads when recording a game. Now the moves being saved as lessons were stronger than gen-202’s own instinct. The student is suddenly imitating something better than the champion — so it can surpass it. And the moment it does, the new champion generates even deeper games, and the next student surpasses that. The improvement compounds. That is the whole trick.

The performance trap that almost hid the win

Deeper thinking isn’t free. Searching twice as deep is twice the work, which should make each round take twice as long — too slow to be worth it. The obvious fix was to play more games at once, using the spare capacity of the graphics card (the GPU) that does the number-crunching. So I doubled the parallel workers… and the speed barely moved. The GPU stayed half-idle.

That was the real lesson of the week: the part I assumed was the bottleneck wasn’t. The workers weren’t the limit — a single “dispatcher” program that hands work to the GPU was. It could only pass jobs along so fast, so the GPU sat half-empty no matter how many workers queued behind it. Running a second dispatcher doubled the flow: the GPU went from half-busy to nearly full, and the deeper search now cost almost no extra time. Twice the thinking, same wall-clock.

The habit this reinforced is almost boring, and almost always right: before you speed up the thing you assume is slow, look at what’s actually sitting idle. A half-empty GPU was the whole tell.

The result, and what’s running now

With those two pieces — deeper search for better lessons, a second dispatcher to keep it fast — the loop broke the gen-202 plateau on the first serious try. Two generations promoted through the untouched referee, and the win rate against a neutral baseline climbed steadily to 0.81. The new champion is gen-205, and it’s now live for players to face. As I write this, an 18-hour run is going deeper still — doubling the search again — to learn whether the same trick keeps paying off or whether the next wall really is about size after all.

The mistakes that cost the most time

Two, both familiar to anyone who measures things. First, I almost trusted a stale number: my initial “this is too slow” verdict was measured against a misleading figure — the first 30 seconds of short opening games, not the true sustained pace. Re-checking the real baseline flipped the conclusion from “hopeless” to “fine.” Re-derive your baseline when a result surprises you. Second, a leftover timer file from a previous run would have made the fresh run quit on startup, and a half-finished batch of practice games would have poisoned the first lesson — both caught only by reading the actual files on disk before launching, never the notes about them.

What this changes

Two plateaus, two completely different fixes: first a bigger brain, now deeper thought. The lesson I’ll carry is that “the model stopped improving” is a symptom, not a diagnosis — each time, the real cause was somewhere I hadn’t looked yet. And the most reusable idea here is almost philosophical: to make a learner surpass its own teacher, have the teacher think harder than it usually does, and distill that back in.

Keywords

Self-play — the AI plays games against itself to create its own training examples, with no human games needed.
Search / look-ahead (MCTS) — before each move the AI imagines many continuations and plays what looks best after looking ahead; more look-aheads means stronger (but slower) play.
Distillation — training a fresh network to imitate a stronger signal; here, the deeply-searched moves of the champion.
GPU — the graphics chip that does the heavy math; keeping it busy is most of the performance battle.
Gate — the statistical referee that only crowns a challenger as champion if it provably wins more games.
Plateau — when strength stops climbing; a symptom whose cause (too small? lessons too weak? a hidden bottleneck?) has to be diagnosed each time.
Compounding — each better champion makes better practice games, so the next student starts from a higher floor.

References

docs/task-log/20260614-yinsh-ai-impl-plan/25-deep-mcts-run-result.md — the run where deeper search broke the gen-202 plateau (new champion gen-205).
docs/task-log/20260614-yinsh-ai-impl-plan/26-deep-mcts-run-kickoff.md — the deeper-still experiment and the performance-bottleneck fix.
docs/guides/yinsh-ai-training-explained.md — a fuller, engineer-level walkthrough of how the whole pipeline works.
#1290 / #1300 — launch of the deeper-search runs. #1297 / #1298 — the smoke test and the second-dispatcher fix.
AlphaZero (DeepMind) — the self-play + search + train loop this pipeline copies.

AI workflow note

This campaign was run by a Claude Code agent, not by hand: it edited the GitOps config, opened and merged the launch/stop pull requests, and watched the multi-hour runs through a loopback network relay because the laptop’s Wi-Fi blocks the cluster directly. The move that mattered most was running a small smoke test before committing to the long run — that’s what surfaced the half-idle GPU and the single-dispatcher bottleneck, turning a “this is too slow” dead-end into a one-line fix. The agent treats each run as one experiment with a written hypothesis and a pre-committed success bar, then reads the result and decides the next step.