Why LLMs Still Can't Play Conway's Game of Life — Test One Yourself

Here's a two-minute experiment. Open a conversation with whatever chatbot you have handy — GPT, Claude, Gemini, doesn't matter which — and paste this:

Simulate Conway's Game of Life. Rules: a live cell with 2 or 3 live neighbors survives; a dead cell with exactly 3 live neighbors becomes alive; every other cell dies or stays dead. Neighbors are the 8 surrounding cells. Here is generation 0 on a 6×6 grid (. = dead, # = alive):
.#....
..#...
###...
......
......
......
Compute generation 4. Show your work generation by generation. Do not write or run code — do this by reasoning about each cell.

That's a plain glider — five cells, the most famous pattern in the entire Game of Life canon. A glider's whole trick is that it repeats its shape every 4 generations, just shifted one cell down and one cell right. It is, by the standards of this universe, about as easy as a moving pattern gets.

Most models still get it wrong. Not on generation 1 — usually somewhere around generation 2 or 3, a neighbor count slips, a cell that should have died survives, and the drift compounds. Ask for generation 8 and the output frequently doesn't resemble a glider at all anymore.

Why this is a real research finding, not a parlor trick

This isn't a "gotcha" prompt. Cellular-automata simulation has become a small but serious line of inquiry into a specific weakness of autoregressive language models: precise, iterated, spatial state-tracking over many steps, where a single misread neighbor count anywhere on the board corrupts everything downstream of it.

A few things worth knowing if you want to go deeper than a chatbot demo:

LifeGPT (originally posted as arXiv:2409.12182, later published in npj Artificial Intelligence) is a from-scratch model trained specifically on Game-of-Life next-state prediction, built as a controlled testbed for exactly this kind of spatial reasoning limit — rather than testing an off-the-shelf chat model, it isolates the skill.
"Intelligence at the Edge of Chaos" (arXiv:2508.16745) studies how models trained on cellular automata of varying rule complexity behave, using the "edge of chaos" — the same complexity regime Conway's rules sit in — as a lens on emergent reasoning capability.
GAMEBoT (ACL 2025, aclanthology.org/2025.acl-long.378) is a broader grid- and game-based benchmark suite for LLM agents that includes cellular-automata-style state-tracking tasks alongside other spatial reasoning challenges.
Informally, the pattern shows up constantly in write-ups like strangeloopcanon's "What can LLMs never do", where mainstream chat models are shown drifting off the correct board state within a handful of generations even on small grids.

None of this means language models are "bad at math" in some general sense — arithmetic and even multi-step logic puzzles are things current models handle reasonably well. It means something narrower and more interesting: iterated, exact, all-cells-at-once state transitions are a specific blind spot, and Life is a uniquely clean way to probe it, because the rule is three lines long and the ground truth is trivial to compute and impossible to fake.

What makes Life a good benchmark in the first place

A useful eval task needs two properties that are hard to get simultaneously: it has to be checkable (you need an unambiguous right answer), and it has to be unmemorizable (a model can't just have seen the answer during training). Game of Life boards satisfy both. Given any starting configuration, the next state is a pure function — no ambiguity, no judgment calls, just neighbor-counting applied uniformly. And because the space of possible boards is effectively infinite, you can always generate a fresh one nobody has published before.

That combination — cheap-to-verify, impossible-to-memorize — is rarer in LLM evaluation than it sounds, and it's a big part of why this niche keeps attracting serious research attention despite being, on the surface, a decades-old hobbyist toy.

Try the harder version

If the four-generation glider was too easy for whatever model you tried, push it:

Swap in a bigger seed — a Gosper glider gun or an R-pentomino will fall apart within 2–3 generations for most models, since both explode into a much larger active region almost immediately.
Ask for more generations at once instead of one at a time — most models do noticeably worse without being walked through it step by step.
Compare against ground truth honestly. The fastest way is to place the same starting cells by hand in our simulator — click the cells directly onto the grid — and step it forward generation by generation. It computes the actual rule, every time, with no drift.

If you want to see what the correct answer to the glider prompt above actually looks like, here it is, computed directly (not guessed) with the standard rule:

Generation 0:      Generation 4:
.#....            ......
..#...            ..#...
###...            ...#..
......            .###..
......            ......
......            ......

Notice it's the same five-cell shape, shifted one cell right and one cell down — exactly what a glider is supposed to do.

Where tool use actually fixes this

There's an important distinction between "can a language model simulate Life by reasoning alone" (the research question above, and it's still mostly "no") and "can an AI agent work with Life correctly" (much more solvable, just not by asking the model to hand-simulate). The fix is the same one that works for most precise-computation tasks: don't ask the model to do the arithmetic in its head, give it a tool that does the arithmetic exactly.

That's the actual design behind our MCP server — instead of asking an agent to guess at cell states, it hands back exact pattern data (in RLE — Run Length Encoded — format) computed the normal way, the same way our simulator does it. An agent using the tools isn't simulating anything by reasoning; it's calling a function and getting the real answer, which sidesteps the exact weakness the research above is about. We're actively extending that tool set further toward letting an agent request and check simulated generations directly, rather than only fetching known patterns — more on that as it lands.

If you're building anything that puts an LLM near a Game of Life board — an agent, an eval harness, a teaching tool — the honest starting point is to assume it can't simulate the rule reliably past a handful of steps, and to design around that rather than hope the next model generation fixes it. For more on where Life intersects the rest of AI research, see our piece on Game of Life and artificial intelligence; if it's finding genuinely new patterns you're after rather than testing models, the modern pattern hunt covers how SAT solvers and distributed search do that today — by computing, not guessing, same as the point above.

Try the four-generation glider on your own favorite model. It's a fast, concrete way to see one of the more interesting current limits of LLM reasoning for yourself, on a board you can check by hand in under a minute.