Mat Zaga

generals.io is a two-player, real-time strategy game where you can't see most of the board. The competition version lets you build castles and gives you 150 ms per move on one CPU core. I started from a published self-play recipe and changed what the network sees, where its games start, how it was pushed to try castles, and how progress was measured.

Below: the training loop, then the improvements. Each letter is an improvement made at that step.

• 38 standard layers: armies, ownership, fog, move history.
• +11 derived: five threat maps — how soon an enemy force reaches each cell, how much could arrive, distance to your own general — computed in one fused pass.
• Countdowns to the turn-800 and turn-1200 rule changes; the raw turn counter can't resolve them in half-precision.
• Castle price per cell, computed by the game's own billing code, so it can never drift.
• A planned “predict the threat” output was cut and made an input: it's computable, so predicting it is leakage.

• Self-play rarely reaches rare decisive moments, so they're mined from 284k human games by exact rules: a castle built then lost within 50 turns; a 20-stack two squares from the enemy general but four by path; land taken behind you after first contact.
• Plus value surprises: moments where the network's own prediction flipped and never recovered.
• Restart 10 turns before the blunder so the network gets to choose differently; keep one tick per episode, not nine copies of one moment.

• A fresh agent never builds — 35+ army up front, slow payback — and a per-castle bonus makes it build everywhere.
• So the bonus is potential-based (Ng, Harada & Russell, 1999): after − before, cancels over a game, can't create a new optimum.
• Castle tries forced only on cells passing four rule checks: repays before turn 1200, leaves ≥1 army behind, no enemy force can reach it in time, nothing unseen within 3 squares.
• The forcing switches itself off on a cell once the network's own urge to build there passes 25%.

• Step size followed an inherited clock, 0.5 / t^1.1, written for one 4,050-step run whose tail is the cooldown.
• Five legs resumed without resetting it: leg 3 stepped at 6.5e-5, leg 5 at 1.6e-5 — cooldown sizes, while still learning. Leg 5 read flat.
• The combination that hurt: tiny steps on a budget a tenth of the top bots'. The fix is two lines — reset the clock at each resume.

• Time-averaged weights ship inside hand-written rules — loop-breaker, mate-in-one check, doomed-castle veto — using 7 ms of the 150 ms budget.
• The other 140 ms measured unspendable: over 274,462 positions, the region a deeper proof needs to see was fully visible 0.89% of the time. Fog, not time, blocks depth.

• ~30,000 games on a laptop, each map played twice with sides swapped so luck cancels.
• Progress had been read against opponents already beaten 95%+ of the time — past that the scale goes blind (one “gate” at 108–0 carried ±3,277 rating points).
• Self-audit: +688 claimed across three legs, +320 real. Fix: score against live ladder ratings of opponents actually drawn; retire any yardstick once beaten past 85%.

• 15 frozen past versions, drawn in proportion to how often they still win; anything beaten >90% gets zero games.
• The draw weighting was found inverted for 1,700 steps — by logging which opponents were actually drawn, not by re-reading the code.

• 200k games on the new rules + 212k on the old. Instead of filtering to strong, current games (−80%), player skill and rule version were fed in as inputs — conditioning embeddings added to attention.
• Pre-registered test: the full messy corpus matched hand-curated data within 49 rating points on a 50-point tie line. Every position in all 8 board symmetries; split by map, not by game.

• Student shape per Straka & Schmid 2026 (deeper over wider at fixed budget). Distilling into a fresh net failed: 1.6% vs its teacher after 48k steps.
• Grew it Net2Net-style instead (Chen, Goodfellow & Shlens, 2016): copy every weight into a deeper net, insert four zero-output layers. Identical function on day one — 49% vs its teacher, untrained.

• ~$41 of GPU behind the shipped version — the chart's x-axis — and ~$185 across every training leg including the dead ends, against $1,000+ for the 3rd-place bot. Paid GPUs only trained; all 30k test games ran on a laptop, after testing had been eating 19% of every paid second on the rented box.

• Seven serving add-ons over ~20k paired games: one read +28, an independent 800 games put it at +4; the unchanged control varied 0.7275–0.7625 across map sets — nothing ships on one batch.
• Four attempts at a specialist to beat the champion (~$7), all collapsed within ~100 steps; each had been started from the champion's weights.
• Before believing “flat”: a snapshot against a bit-identical copy of itself scored exactly 0.5000.