Autoresearch Recursive Games - Part Two

Connect Four was one experiment on the research loop. Here are ten more — each chosen to break a different part of.

game	metric	status	stresses
nim	win_rate	queued	greedy selection vs grokking
kuhn_poker	exploitability	queued	non-transitive strength
2048	mean_score	queued	noisy fitness signal
ultimate_ttt	win_rate	queued	hierarchy in the blueprint
hex_7x7	win_rate	queued	inherited inductive bias
othello_6x6	win_rate	queued	internal world models
gomoku_9x9	win_rate	queued	transfer between runs
tetris	lines_cleared	queued	paradigm loyalty
minesweeper	solve_rate	queued	distance from optimal
mini_hanabi	team_score	queued	cooperative conventions

The next page of the ledger. Nothing here has run yet — that's the point.

In the last post I described autoresearch-connect4: an AI agent that edits a training script overnight, runs five-minute experiments, and keeps or discards each change based on a single sacred number. The interesting object isn't the Connect Four player it produces. It's the research loop itself — a machine doing research on machines that learn, small enough to audit over coffee.

But one game is one data point. Connect Four is a perfect-information, zero-sum, line-making game with a mostly-honest scalar metric — which means the loop has only ever been tested under the friendliest possible conditions. If the pattern is going to teach us anything general about recursive AI, it needs substrates chosen to stress it, not flatter it.

So here are ten games, selected the way you'd select test cases: each one attacks a different assumption the current loop quietly makes. Same three-file architecture every time — immutable engine and metric in prepare.py, one mutable train.py, instructions in program.md — so the results are comparable across games. What changes is which joint of the recursion gets bent.

group 1keepattacking the keep/discard rule

Three games that attack the outer loop directly

The loop's core assumption is that hill-climbing on one scalar is a reasonable model of research. These three games each falsify part of that.

1 Nim — the grokking trap

Nim has an exact solution: XOR the pile sizes and act on the parity. So the question stops being "can it play better?" and becomes "can the inner loop discover an algorithm, and will the outer loop let it?" Grokking — the sudden jump from plateau to perfect generalization — is exactly the dynamic that greedy selection punishes: a change that would grok at minute eight looks flat at minute five and gets discarded. The morning-after experiment writes itself: re-run a sample of discarded changes with a longer budget and count the false negatives. That number is a measured limit of scalar-feedback self-improvement.

2 Kuhn poker — when "better" stops being a direction

Every game so far has roughly transitive strength. Poker doesn't: optimal play is a mixed strategy, self-play dynamics cycle, and A beating B beating C tells you nothing about A versus C. Kuhn poker is small enough that exploitability — distance from Nash equilibrium — is exactly computable, so it becomes the sacred metric. Now the loop is hill-climbing on a landscape where the game has no best pure strategy at all. Does it converge, cycle, or thrash? The ledger will say, and whichever answer it gives is a result about recursive optimization in non-transitive domains, which is most interesting domains.

3 2048 — does the researcher invent statistics?

2048 removes the opponent and adds dice: random tile spawns make the evaluation genuinely noisy even over a fixed seed set. Many of the loop's "improvements" will be luck. The design here is a little sly — program.md says nothing about noise. The question is whether the agent, facing a metric that won't sit still, spontaneously starts demanding effect sizes, re-running experiments, or averaging over more games. A researcher that invents significance testing because its world required it would be a genuinely striking thing to find in the ledger.

group 2keepstructure and representation

Four games about what the blueprint learns

The outer loop selects architectures. These four games ask what, exactly, gets selected for.

4 Ultimate Tic-Tac-Toe — recursion in the board itself

A 3×3 grid of 3×3 boards, where your move dictates which sub-board your opponent plays in next. The game is literally hierarchical, which makes it the cleanest test of a lovely question: does structure in the problem end up reflected as structure in the blueprint? Seed the idea list with flat and hierarchical encodings as equal citizens, and watch which lineage the kept experiments belong to. Three nested loops — research over learning over a recursive game — is also, frankly, the best thematic fit in the whole set.

5 Hex — is the CNN actually load-bearing?

Connect Four, Gomoku, and Tic-Tac-Toe are all line-making games, which convolutions are practically purpose-built for. Hex is a connection game: you win by completing a topological path across the board, and there are no draws — every filled board has exactly one winner, making the metric unusually clean. The convolutional inductive bias the project inherited from Connect Four may simply be wrong here. Whether the loop notices, and what it reaches for instead — dilations, attention, distance-to-connection features — measures whether autoresearch can escape the priors it was born with.

6 Othello — selecting for world models

Othello's flipping mechanics mean a network can't evaluate positions well without internally modeling the rules — which is why it became the canonical testbed for emergent world models in the interpretability literature. The twist here: add a linear probe as a morning-after diagnostic (outside the sacred metric), and check whether experiments the loop kept have measurably better internal board representations than ones it discarded. If win-rate selection implicitly selects for world models, that's a bridge between recursive optimization and interpretability that neither field currently has data on.

7 Gomoku — does research transfer?

Gomoku is Connect Four's nearest neighbor, which makes it the control for the most recursive question in the set: run it twice, once cold and once with program.md seeded with the findings — not the weights, the written findings — of the Connect Four run. The difference in experiments-to-threshold between the two branches is a number that measures whether machine research output is useful input to machine research. That is recursion across runs, and as far as I know nobody has measured it at any scale, large or small.

group 3keepnew axes entirely

Three games that change what "research" means

8 Tetris — will it abandon deep learning?

Tetris is the famous embarrassment of naive RL: hand-crafted features — holes, bumpiness, column heights — tuned by simple evolutionary methods have long demolished deep networks under tight compute. The baseline train.py is deliberately the wrong approach: a CNN trained with REINFORCE. Everything in the file is fair game, including deleting the network and replacing it with a weighted feature policy. So the game becomes a loyalty test: is the loop actually open-minded about paradigms, or does it only ever polish the one it was seeded with? An overnight run that ends with the neural network gone would be my favorite possible result.

9 Minesweeper — a frontier with a printed ceiling

No opponent, no lines — Minesweeper is pure probabilistic inference over constraints, and some positions force a guess no matter how good you are. That irreducible loss means the metric has a computable ceiling below 1.0, which no adversarial game offers: you can publish optimal play right in the README and measure the loop's gap to optimal rather than its edge over baselines. Progress toward a known ceiling is the cleanest picture of recursive improvement you can draw — an asymptote you can watch the ledger approach, row by row.

10 Mini-Hanabi — recursion meets cooperation

Everything above is zero-sum or solo. Hanabi is cooperative with hidden hands: you see your partner's cards but not your own, and success requires inventing conventions — a private language of hints — through self-play. Conventions are exactly the kind of thing that is locally optimal and globally brittle, and self-play pairs are notorious for developing dialects that collapse when matched with anyone else. The elegant twist: evaluate each new agent not just with itself but paired with agents from earlier kept experiments. The run's own history becomes part of the evaluation — the ledger stops being a record of the recursion and starts participating in it.

commit —closingkeepwhy ten

One loop, ten stress tests

Connect Four told us the loop works when conditions are friendly. These ten are chosen to find out where it breaks — and every break is a finding.

The order matters less than the coverage, but if I had to pick: Nim and Kuhn poker go first. They're the smallest engines to build and they aim at the loop's most foundational assumption — that greedy hill-climbing on one scalar is a workable model of research — from two independent directions. Ultimate Tic-Tac-Toe, Othello, and Gomoku follow for the structure-and-transfer story. The last three each open an axis the others can't touch: noise, paradigm loyalty, and cooperation.

Ten games, one immutable judge per game, one mutable file, one long night each. The ledgers that come back won't just describe ten stronger game players. Together they'll form something rarer: an empirical map of how a recursive researcher behaves — where it's reliable, where it's greedy, where it fools itself, and where it surprises you.

The queue is set. Time to let it run.

Part two of the autoresearch series. Part one: The Overnight Researcher.autoresearch-connect4 — modeled on karpathy/autoresearch.