Can an LLM play Tetris?

The question

Tetris is a clean spatial-reasoning probe. The board is small, the rules fit in a paragraph, and a textbook heuristic from 2003 plays it nearly perfectly. So: when a language model is handed the board as text and asked to pick a placement, what does it actually do, and when it fails, is it failing to read the board or failing to plan?

The second half of that question is the interesting one. A model that misreads column heights and a model that reads them correctly but stacks badly need different fixes, and a raw score cannot tell them apart. The first version of this write-up inferred the answer from token counts. This version measures it.

Setup

• Turn-based engine. No gravity clock. The model sees a 10×20 ASCII board, the current piece with rotation diagrams, and replies with {"rotation", "column", "why"}. The engine hard-drops it. Slow models are not punished for being slow.
• Paired seeds. Every condition plays the same five piece sequences (7-bag), so differences are the model, not the luck. Games cap at 250 pieces.
• Two anchors. A random-legal-move floor and a Dellacherie heuristic ceiling. Every model move is scored against the heuristic's best choice (regret: 0 means you played like the reference AI).
• Two-layer error taxonomy. Interface errors (no JSON, illegal rotation, truncated) are separated from strategic errors (created a hole, missed an available clear). After two retries a random legal move is substituted and flagged as a fallback.
• Board-reading probe. Separately from the games, each model is shown 60 real mid-game boards (replayed from finished games, stratified from near-empty to 20 rows tall) and asked only for the ten column heights. Mean absolute error in rows, no move involved. This is the perception measurement.
• Prompt conditions. standard (mechanics specified, one strategy hint). coached adds a playbook and forces a height report. JSON only forbids any text before the answer. CoT in output asks for a short board analysis in the visible response, no playbook. Thinking mode (reasoning in the model's hidden channel) is a separate switch.

The local models run on two RTX A6000s via Ollama at 8k context (40k for the unbounded thinking runs). Claude Haiku 5.5 and Sonnet 5.5 run through an Azure AI Foundry endpoint using the identical prompt, board, seeds and limits.

Results

First, what the numbers look like as play. Same seed, so every player sees the identical sequence of pieces; the boards are deterministic replays of the recorded moves, and the grey line under each board is the model's own one-sentence reason for its last placement.

Four views of the same games. Lighter bars are the cloud models; the dashed line is where random play lands.

Full table

Pieces survived is the headline: a game ends when the stack tops out or hits the 250-piece cap. Regret is averaged over every move (random ≈ 114). "Moves that make holes" is the share of legal moves that covered at least one empty cell.

What the table says

• Without reasoning, nobody beats random. Random survives 19.6 pieces. The seven local models with the standard prompt survive 9–13 (gpt-oss, which reasons whether you ask or not, 26.6). Haiku with thinking off: 25.6. Sonnet with its spontaneous analysis suppressed: 33.8. The interface is fine (0% fallbacks for most); the pieces just go in the wrong place.
• With reasoning in the thinking channel, the large frontier models reach the 250-piece cap. GPT-6.1 Sol: 250.0 pieces in every game, 90.8 lines, average score 27,828 against the heuristic's 22,800; it out-scores Dellacherie on 4 of 5 seeds by taking Tetrises and triples where the heuristic takes singles. Sonnet 5.5 at high effort: 206.8 pieces, 72.0 lines, 3 of 5 games to the cap. Hole-creating moves 10% and 11% against the heuristic's 2%. The 250 cap is a ceiling here; see the 1,000-piece section for what happens when it is lifted.
• The small frontier models replicate across companies. Haiku with thinking: 128.8 pieces (spread 67–208). GPT-6 Luna with reasoning: 48.6, despite spending 2.5× Haiku's reasoning tokens and reading the board better. Without reasoning Luna survives 16.6 pieces, below random. The size penalty is not an Anthropic quirk.
• Every other way of reasoning lands in the same place. Local models with thinking on, local models with a coached prompt, Haiku with chain-of-thought in the output, Sonnet forbidden from thinking but allowed its output analysis: 32.0–36.8 pieces, 1–3 lines, 22–30% heuristic agreement. Seven conditions across five models and two prompt families, one number. Something about "reason in text, then commit" caps out there. The exception is Nemotron Bolt with thinking (92.0 pieces, 21.5 lines over 2 games, one of them 124 pieces); see the section on the two late models below. The Sokoban bench also argues the plateau is partly a Tetris artefact: on short puzzles the same local thinking runs span 40–90%.
• Where the reasoning happens matters, for Haiku. Same model, same prompt, same kind of board analysis: in the hidden thinking channel it survives 128.8 pieces; written into the visible output it survives 36.8. For Sonnet the gap is smaller (91.6 with output reasoning vs 206.8 with thinking) but in the same direction.

Reading the board

This is the measurement the first version of this page lacked. Sixty real boards, heights only, no move to choose.

Three things fall out.

• For most local models, perception is the first wall. Gemma, Qwen 3.8, Qwen 3.5, Nemotron and Granite misread the board by 1–5 rows per column with thinking off. One row of error turns a flush placement into a hole; these models create holes on 60–70% of moves. Error grows with stack height: Haiku-no-think reads a short stack at 0.3 rows and a tall one at 1.7.
• Thinking fixes perception, even for local models. Gemma with thinking reads at 0.14 rows error, Qwen at 0.22. That is the same accuracy as Haiku with thinking (0.14), which survives 128.8 pieces. Gemma with thinking survives 35.5. Same eyes, different game.
• Two local models read the board nearly perfectly and still cannot play. gpt-oss (0.02 rows, 92% of boards exact) and Muse Glimmer (0.07) are the best readers in the table, including the cloud models. gpt-oss given unbounded thinking (40k context, no cap, ~6k tokens per move) survives 34.5 pieces. Perception is not its problem.

So the honest answer to the opening question is: both, in sequence. Most local models fail at perception first; give them a reasoning channel and perception is fixed; then they fail at planning, and so does every model that reasons in visible text rather than a thinking channel. What the Claude thinking channel does that 6,000 tokens of Qwen or gpt-oss deliberation does not, we cannot see from the outside. The output is a single placement either way.

Board misreading, with confidence

The why field makes the perception failure legible. Models explain a move in terms of a board that does not exist. Haiku, thinking off, placing a Z that created two holes:

"Flat Z placement on the low ground beside the existing 2x2 block keeps the stack flat with no holes; rotation 0 at column 1 rests its bottom row on the floor at columns 2-3 and its top row over columns 1-2."

The description of the piece geometry is correct. The description of where it lands is not. Smaller local models also show a strong positional fixation: Granite puts 87% of its pieces in column 4, which reads as "centre is safe" applied without looking.

Scenarios: insight vs. planning

Fixed boards with a forced piece, scored 0–1. The one-move tasks (cash a prepared Tetris, find the only two-line fit, survive a cliff) are solved by nearly everyone. The multi-step tasks (dig out of garbage, stack twelve pieces without a hole) separate the field the same way the games do: Sol scores 0.83 and 0.89, Sonnet with thinking 1.00 and 0.78, Haiku with thinking 0.94 and 0.44, the plateau conditions 0.2–0.3 and near zero, the no-reasoning conditions zero.

Lifting the cap: 1,000-piece games

At 250 pieces Sol and Sonnet look finished: every Sol game and three of five Sonnet games hit the cap, and Sol's score beats the heuristic's. That is a ceiling effect. Three games each at a 1,000-piece cap, same seeds, same settings:

• Nobody is at the heuristic. It runs 1,000 for 1,000 on every seed. Sol gets 446 pieces on average, Sonnet 338, and every one of their six games ended by their own move. Sol's seed-3 game died at 165, before the 250 mark it had cleared on the same seed in the short run, so game-to-game variance at the top is large.
• Per-move quality does not decay; damage accumulates. Sol's regret is 8.0 in the first 250 moves and 8.0 after; Sonnet's 7.4 then 6.3. But holes on the board go from 4.7 to 7.3 (Sol) and 6.0 to 11.7 (Sonnet). The models keep making mostly-good moves and never dig out the few bad ones. Dellacherie keeps the board under 0.3 holes forever.
• The 250-piece score lead was a head start, not a trend. Sol's stacking style (Tetrises and triples, the heuristic takes singles only) banks more points per line early, but the same style leaves tall stacks that a misread kills. Over 1,000 pieces Sol is at a third of the heuristic's lines and a quarter of its score.

So the ceiling story as of this revision: a frontier reasoning model gets a third to half of the way to a 2003 hand-coded heuristic on a long game, and the gap is recovery, not move selection.

Temperature replication

The cloud models play at their default temperature; the local models at 0.2. Every local model re-run at 1.0, standard prompt, five games:

Nothing moves outside noise. The temperature asymmetry is not what separates the local models from the cloud ones.

Two late additions: Nemotron 3.5 Bolt and Qwen 3.8 Flash-Next

Both arrived after the main sweep and both are shipped in forms that matter for how they should be read. Speed numbers are warm, thinking off, identical prompt, each model alone on the two A6000s.

• Nemotron 3.5 Bolt, 74B total / 9B active, IQ2_XXS. Nvidia's only release is a 2-bit quant, 25 GB, so the quant is the product rather than a confound. It is the fastest model on this box by 2× and fits on one GPU. Thinking off, it is the worst spatial reader in the table: 3.20 rows of height error, 3% of boards read exactly, 10.8 pieces survived, coached 17.6. Thinking on: 92.0 pieces and 21.5 lines, 23% hole-creating moves (Claude-thinking range), at ~25k reasoning tokens a move, five minutes a piece even at its speed. The reading we would defend is that the 2-bit quant damaged direct perception and left reasoning mostly intact, and that the speed 2 bits buys is what makes 25k tokens per move tolerable. Two games; treat the exact number loosely, the direction less so.
• Qwen 3.8 Flash-Next, 125B total / 6B active, Q4. 120 GB on disk against 96 GB of VRAM; Ollama holds ~85 GB on the GPUs and the rest in system RAM, and still generates at 0 tokens a second because only 6B parameters are touched per token. It is the best no-think local model here (17.2 pieces, height error 1.56) and the one that gains least from thinking: 34.5 pieces, exactly the plateau. Coached it cleared lines in two of five games, the first no-think local to do so, at the cost of 42% fallback moves from overrunning its budget.

Both are run through the identical treatment on the Sokoban bench, where the picture is sharper: Bolt with thinking solves 9 of 10 easy puzzles and Flash-Next 6.

Does size buy anything?

Nine local models, same harness, same prompts, plotted against parameter count. Mixture-of-experts models have two sizes, so each one is drawn as a bar from its active parameters (what runs per token) to its total (what is stored), with the marker at the geometric mean, the usual dense-equivalent rule of thumb. Rank correlation with size is printed for all three conventions; if the conclusion depended on which you pick, the signs would disagree.

• There is no trend because there is no spread. Taken as dense-equivalents, all nine land between 24B and 38B. The "big" models (gpt-oss, Qwen 3.5, Nemotron 3 Super, Flash-Next) are 5-12B models with a large store of experts, and they score like it. Within that half-decade of size, board-reading error varies 4x and Tetris survival 3x. Architecture, training and quantization explain the table; parameter count does not.
• Every correlation is flat or the wrong way. Spearman against the geometric mean: board reading +0.33 (wrong direction, lower error is better), Tetris pieces -0.70, Sokoban with thinking -0.67 (n=5). The negative signs are mostly the two Nemotron MoEs at the bottom of the no-think panels, which is a 2-bit quant and 22-of-512 routing story, not a size one.
• The models that would make this chart interesting are the ones without a published size. Claude and GPT-6 rows sit well above every local model on these tasks; everything else in this write-up says the gap is compact reasoning, a training effect, not a count.

What I'd change

• The "plateau at ~35 pieces" is the most interesting thing here and we have no mechanism for it. Next step is to diff the Sonnet thinking transcripts against its visible-output analyses on the same boards (Azure returns thinking token counts but not the text, so this needs the direct Anthropic API) and look for what the thinking channel does that the output channel doesn't: more candidate placements considered, explicit lookahead to the next piece, or just less commitment to the first idea.
• The long-game failure is "never digs out." A prompt that names the hole count and asks the model to prioritise clearing covered cells would test whether that is a strategy gap (fixable with words) or a planning-depth gap (not).
• Sol at high or xhigh effort on the 1,000 cap, to see whether more reasoning buys recovery or just more of the same.
• Local thinking rows should go to 5 games. Overnight each.
• Board-as-image for the Claude models and Gemma. The probe says text perception is solved by thinking, so this is now a cost question rather than a capability question, but it would be good to know.
• Thirty paired games for the top conditions. Sonnet-thinking's one 79-piece game and Haiku-thinking's 67–208 spread both say five is thin at the top of the table.

Changelog

• November 02, 2026 - Added the size-vs-score figure (all nine local models, MoE drawn as active-to-total bars) and corrected Nemotron 3 Super's architecture: it is a 120B-A12B mixture of experts (512 experts, 22 routed), not dense.
• October 27, 2026 - Added Nemotron 3.5 Bolt (2-bit, as shipped) and Qwen 3.8 Flash-Next in standard, coached, temperature-1.0 and thinking conditions, plus the board-reading probe and a warm throughput table for every local model. Bolt with thinking is the first local run off the ~35-piece plateau; the plateau claim is softened accordingly. Companion Sokoban bench published.
• October 2026 - Added GPT-6.1 Sol and GPT-6 Luna (Azure Responses API, reasoning on/off where the model allows it). Added 1,000-piece games for Sol, Sonnet-high and the heuristic: the 250 cap was a ceiling effect, and the "matches the heuristic" claim from the previous revision is withdrawn for long games. Added GPT rows to the board-reading probe.
• October 2026 - Major revision. Added the board-reading probe (60 boards, all models). Added Claude Sonnet 5.5 at thinking-high (new ceiling), Sonnet JSON-only and Haiku CoT-in-output (the reasoning-location pair), gpt-oss unbounded thinking, and a temperature-1.0 replication of every local model. Discarded a Sonnet thinking-medium run after finding it produced zero thinking tokens. Rewrote the perception-vs-planning argument around measured numbers; the earlier inference from token counts was half right.
• October 2026 - Added Claude Sonnet 5.5 (thinking off) and local thinking-mode runs for Gemma 4 (8k budget) and Qwen 3.8 (unbounded). Patched the Anthropic client for Sonnet's between_tools thinking switch.
• October 2026 - Added Claude Haiku 5.5 (thinking off and on) as a frontier reference. Patched the bench's Anthropic client for Azure Foundry routing, the removed temperature parameter, and the adaptive-thinking API.
• September 2026 - v2 of the bench: paired seeds, error taxonomy, scenarios, coached prompt, seven local models.
• July 2026 - v1. Every thinking-capable model failed 100% of moves by exhausting its budget in the reasoning channel. That finding became the "thinking off by default" rule.