TIS-100 Bench: LLMs Push the Pareto Frontier in Programming Puzzle Games

Twelve nodes. Two registers per node. Fifteen lines of code. In TIS-100, even multiplying two numbers is a small engineering project, and players have spent a decade optimizing these programs on a public community leaderboard. We gave 16 LLMs the game and its manual, withheld the leaderboard, and told them to keep improving.

133new frontier points
18 / 55puzzles with new frontier points
3outright cycle records

Within days, players picked up the models’ programs and improved on most of them.

Each node is a tiny processor, and neighboring nodes have to wait for one another to exchange values. The game scores a working solution on cycles, nodes, and instructions, and you start wondering whether one more instruction could disappear. Lower is better, but improving one score can make another worse, so each puzzle has a frontier of tradeoffs instead of one best answer.

Leaderboard

We ran 16 LLMs, covering leading frontier and open-weight models. Every model attempted all 47 puzzles in the game, plus eight community tournament puzzles, in one scored attempt each (pass@1), with 10 to 45 minutes per puzzle, depending on difficulty, to find a working program and keep improving it.

Model ranking

Puzzles with at least one new frontier point · higher is better

All 55 puzzles · 19 easy / 17 medium / 19 hard

  1. 11 of 55 puzzles with a new frontier point
    Opus 5.5
  2. 11 of 55 puzzles with a new frontier point
    GPT-6 Astra
  3. 8 of 55 puzzles with a new frontier point
    Gemini 4 Argon
  4. 7 of 55 puzzles with a new frontier point
    Sonnet 5.5
  5. 6 of 55 puzzles with a new frontier point
    GPT-6.1 Sol
  6. 5 of 55 puzzles with a new frontier point
    Fable 5.1
  7. 2 of 55 puzzles with a new frontier point
    Kimi K3.1 Pro
  8. 1 of 55 puzzles with a new frontier point
    Gemini 3.8 Flash
  9. 1 of 55 puzzles with a new frontier point
    Muse Wonder 1.0
  10. 1 of 55 puzzles with a new frontier point
    Haiku 5.5
  11. 1 of 55 puzzles with a new frontier point
    GLM-5.3
  12. 0 of 55 puzzles with a new frontier point
    Grok 4.7
  13. 0 of 55 puzzles with a new frontier point
    DeepSeek V4.1 Flash
  14. 0 of 55 puzzles with a new frontier point
    Muse Spark 1.3
  15. 0 of 55 puzzles with a new frontier point
    GPT-6 Luna
  16. 0 of 55 puzzles with a new frontier point
    MiMo-V2.6-Pro

Scroll horizontally to compare all models →

A point counts only with fresh-game replay and 100,000 passing tests.

Opus 5.5 and GPT-6 Astra lead, and the data doesn’t separate them. Both solved all 55 puzzles and both found new frontier points on 11. Opus 5.5 found more points, 72 to 32, while GPT-6 Astra has the higher record proximity, 78.0 to 77.2. Record proximity measures closeness to the community records, where 100 means matching them. The proximity gap’s 95% bootstrap interval includes zero, from −0.7 to +2.4 points. GPT-6 Astra also leads in all six tested hypervolume settings, which measure the space covered by each model’s tradeoffs.

Solving and optimizing are also different skills. Gemini 3.8 Flash solved 53 puzzles and found new points on 1; Fable 5.1 solved fewer, 52, and found new points on 5.

Full rankings Expand the table
TIS-100 benchmark model rankings. Select column headings to sort.
01Opus 5.5 55 / 5511 77.2
02GPT-6 Astra 55 / 5511 78.0
03Gemini 4 Argon 54 / 558 76.2
04Sonnet 5.5 53 / 557 69.9
05GPT-6.1 Sol 54 / 556 75.6
06Fable 5.1 52 / 555 70.2
07Kimi K3.1 Pro 52 / 552 64.6
08Gemini 3.8 Flash 53 / 551 66.0
09Muse Wonder 1.0 49 / 551 58.8
10Haiku 5.5 45 / 551 53.7
11GLM-5.3 30 / 551 35.5
12Grok 4.7 44 / 550 50.1
13DeepSeek V4.1 Flash 40 / 550 46.8
14Muse Spark 1.3 39 / 550 45.1
15GPT-6 Luna 39 / 550 42.8
16MiMo-V2.6-Pro 10 / 550 12.8

Counts are out of 55 puzzles. Methods

RL environments & traces are available upon request for research teams. Get in touch ↗

How it works: harness design

Every result here is a program we can run and test on fresh inputs, which makes a programming game a useful benchmark. Models get what a player can inspect, through text tools instead of a mouse and screenshots: the manual, visible test inputs, registers, and game feedback. They don’t get community code or exact records, only the game’s coarse score histograms.

Read, edit, run
Models read the puzzle and language reference, edit programs, and run them in the real game.
Diagnostics
Wrong outputs and deadlocks return mismatches, registers, and blocked ports, so the next edit can respond to evidence.
Saved progress
Every passing program joins the model’s own frontier and can be recovered with get_best, so a risky edit can’t lose an earlier result.
Reminders
If a model ends its turn early, a reminder asks it to keep testing, so quitting early doesn’t decide the score. Reminders contain no solution hints.
A visible clock
Models see time used against a 10-, 30-, or 45-minute limit. Setup doesn’t count; thinking and game calls do. Models can’t end an episode early.
Run limits
Game execution stops after roughly 1 second without state changes, 5 seconds without output, or 60 seconds overall, and returns diagnostics.

Why test 100,000 inputs? The game checks a small set of cases per run. Our headline count requires a fresh-game replay and 100,000 passing tests on the independent TIS-100-CXX simulator, providing stronger evidence that a program generalizes to new inputs.

One record up close

Undecimal Twin RounderSPEC44149538, one of the eight tournament puzzles, rounds an input to the nearest multiple of N on one output and of 11−N on the other. When we froze the leaderboard, the best community program took 2,694 cycles. Opus 5.5 passed its first program after 6.5 minutes, at 5,669 cycles. It went under the record 16 minutes in and finished at 1,918, which is 29% faster. That speed cost one more node and 28 more instructions than the old record.

The core of the program is a two-speed search. Instead of subtracting N one step at a time, nodes 5 and 6 subtract 4N until they overshoot, then add N back until the value turns positive. Each drives a small coprocessor, node 2 or node 7, by sending it jump offsets through a port, so the coprocessor works as a lookup table for 4N and N.

The 1,918-cycle program

Opus 5.5 · 8 nodes · 88 instructions · passes 100,000 of 100,000 tests

Node 0
MOV RIGHT, ACC
JRO ACC
NOP
ADD 1
NOP
ADD 1
NOP
ADD 1
NOP
SUB 3
MOV ACC, RIGHT
ADD UP
MOV ACC, RIGHT
MOV ACC, DOWN
MOV RIGHT, DOWN
Node 1
MOV UP, ACC
SAV
SUB 1
MOV ACC, LEFT
NEG
ADD 10
MOV ACC, DOWN
MOV LEFT, ACC
NEG
ADD ACC
ADD 6
ADD LEFT
MOV ACC, DOWN
SWP
MOV ACC, LEFT
Node 2
MOV UP, DOWN
MOV UP, ACC
SAV
ADD ACC
ADD ACC
L: JRO DOWN
MOV ACC, DOWN
JMP L
SWP
N: MOV ACC, DOWN
M: JRO DOWN
JMP N
MOV DOWN, DOWN
Node 3
MOV UP, RIGHT
MOV UP, DOWN
Node 4
MOV LEFT, DOWN
Node 5
MOV UP, ACC
SAV
K: MOV 1, UP
SUB UP
JGZ K
MOV 3, UP
F: ADD UP
JGZ X
MOV 1, UP
JMP F
X: MOV 2, UP
MOV ACC, UP
SWP
SUB UP
MOV ACC, DOWN
Node 6
MOV UP, ACC
SAV
K: MOV 1, RIGHT
SUB RIGHT
JGZ K
MOV 3, RIGHT
F: ADD RIGHT
JGZ X
MOV 1, RIGHT
JMP F
X: MOV 2, RIGHT
MOV ACC, RIGHT
SWP
SUB RIGHT
MOV ACC, DOWN
Node 7
MOV UP, ACC
SAV
ADD ACC
ADD ACC
L: JRO LEFT
MOV ACC, LEFT
JMP L
SWP
N: MOV ACC, LEFT
M: JRO LEFT
JMP N
MOV LEFT, LEFT
Laid out on the puzzle’s real grid, with inputs at the top and outputs at the bottom. Blank tiles are damaged and can’t be used.

Loading puzzle trajectories…

Five models got under the old record in-game. The other two cycle records are GPT-6.1 Sol’s 3,460 on Intersection IdentifierSPEC64160260, against 3,872 (11% faster), and Gemini 4 Argon’s 188 on Error: 8SPEC79324720, against 198 (5% faster). All three are on tournament puzzles, none in the main game. Of the 133 new frontier points, 18 beat a community record outright. The other 115 are new tradeoffs: better balances between the three scores than any community solution.

A new frontier point running in the real game: Opus 5.5 on Prime Factor CalculatorNEXUS.20.433.1, at 1,806 cycles, 10 nodes, and 103 instructions.

What separates the models

Cost doesn’t track quality

GPT-6.1 Sol reaches 75.6 record proximity at an estimated $0.75 per puzzle. Opus 5.5 reaches 77.2 at $5.08, 7 times the cost for 2 more points. Fable 5.1 is the most expensive at $7.19 and scores 70.2.

880episodes
95.5Moutput tokens
62,400game-tool calls
Loading analysis…

What the models built

We grouped all 55 puzzles by their main demand, then read the programs. Fifteen of the sixteen models solved all five routing puzzles, and none found a new frontier point there. The examples below show how different designs spend the same resources.

Performance by puzzle mechanic

Fraction solved · puzzles with new points below

ModelRouting & synchronization5 puzzlesArithmetic construction13 puzzlesSequence algorithms14 puzzlesStreaming state8 puzzlesMemory & interpreters4 puzzlesImage generation11 puzzles
GPT-6 Astra5/50 new13/136 new14/142 new8/82 new4/40 new11/111 new
Opus 5.55/50 new13/133 new14/143 new8/83 new4/41 new11/111 new
Gemini 4 Argon5/50 new12/134 new14/140 new8/82 new4/40 new11/112 new
GPT-6.1 Sol5/50 new12/131 new14/143 new8/81 new4/40 new11/111 new
Fable 5.15/50 new12/132 new13/141 new7/81 new4/41 new11/110 new
Sonnet 5.55/50 new12/133 new13/141 new8/83 new4/40 new11/110 new
Gemini 3.8 Flash5/50 new12/131 new13/140 new8/80 new4/40 new11/110 new
Kimi K3.1 Pro5/50 new12/130 new13/141 new7/81 new4/40 new11/110 new
Muse Wonder 1.05/50 new12/131 new10/140 new8/80 new4/40 new10/110 new
Haiku 5.55/50 new11/131 new11/140 new6/80 new4/40 new8/110 new
Grok 4.75/50 new10/130 new9/140 new7/80 new4/40 new9/110 new
DeepSeek V4.1 Flash5/50 new10/130 new9/140 new6/80 new4/40 new6/110 new
Muse Spark 1.35/50 new11/130 new9/140 new4/80 new2/40 new8/110 new
GPT-6 Luna5/50 new11/130 new10/140 new4/80 new2/40 new7/110 new
GLM-5.35/50 new10/131 new6/140 new3/80 new2/40 new4/110 new
MiMo-V2.6-Pro3/50 new4/130 new1/140 new1/80 new1/40 new0/110 new

Multiplication: spend code to save cycles

Signal Multiplier43786 has no MUL. Gemini 4 Argon and GPT-6 Astra use JRO, a relative jump, to enter a block of repeated instructions at the right position. The jump selects how many copies of a value to send and add, saving the counter updates and branches of a multiplication loop.

Gemini 4 Argon’s fastest program uses two paths to multiply in parallel and a final node to interleave their outputs. It takes 436 cycles against GPT-6 Astra’s 523, about 17% faster, at a cost of two more nodes and 33 more instructions.

The cost of a faster multiplier

Cycles per run · lower is better

Gemini 4 Argon436 cycles

7 nodes · 64 instructions

GPT-6 Astra523 cycles

5 nodes · 31 instructions

Window sums: distribute the history

Signal Window Filter60099 outputs the sums of the last three and last five inputs, so a solution has to remember history as well as add. Gemini 4 Argon’s four-node program uses SWP to rotate stored values and ADD/SUB to update running state. GPT-6.1 Sol spreads that delay and aggregation across seven nodes, passing intermediate values between them.

GPT-6.1 Sol’s program runs in 318 cycles with 26 instructions; Gemini 4 Argon’s takes 428 cycles with only 17. The difference is how much of the work runs in parallel, and how much communication and code that costs.

ModelCyclesNodesInstructions
GPT-6.1 Sol318726
Gemini 4 Argon428417

Indexed access from stacks

T31 Node EmulatorNEXUS.23.727.9 needs eight addressable storage slots, but the available memory nodes are stacks. These programs move values between stacks to reach the requested slot, then read or replace it. MiMo-V2.6-Pro uses counted transfer loops; Opus 5.5 uses JRO to pick among unrolled transfers, spending extra instructions to save cycles.

Memory isn’t one skill: MiMo-V2.6-Pro solves this emulator but fails Sequence Mode CalculatorNEXUS.09.904.9 and Signal Window Filter60099.

ModelCyclesNodesInstructions
Opus 5.5215663
GPT-6 Astra365447
MiMo-V2.6-Pro451434

Each row is that model’s fastest saved program for the puzzle, picked for illustration. Not all are new frontier points.

God mode: what if the model could see the target?

The main benchmark hides the community’s scores. In a separate study on six puzzles, five models got:

  • The target: exact community scores, showing which tradeoffs remain unbeaten.
  • Diagnostics: cycle-by-cycle traces and profiles of where each node stalls.
  • Edge cases: a fast simulator that runs 10,000 random tests and returns failures.
  • More time: 30 minutes, plus extensions for progress, up to 60.

Every model improved: GPT-6 Astra from 82.8 to 91.8, GPT-6.1 Sol from 82.9 to 90.6, Opus 5.5 from 81.4 to 89.1, Grok 4.7 from 67.5 to 75.1, and Gemini 4 Argon from 83.5 to 87.9 in mean record proximity. Scores rose in 28 of the 30 model–puzzle pairs.

Score quality with a richer setup

Mean record proximity · same six puzzles per model · higher is better

Standard episodeGod mode
Mean record proximity across six matched puzzles020406080100Opus 5.5: standard 81.41; god mode 89.11 points81.489.1Opus 5.5GPT-6 Astra: standard 82.78; god mode 91.76 points82.891.8GPT-6 AstraGPT-6.1 Sol: standard 82.86; god mode 90.58 points82.990.6GPT-6.1 SolGemini 4 Argon: standard 83.55; god mode 87.87 points83.587.9Gemini 4 ArgonGrok 4.7: standard 67.54; god mode 75.11 points67.575.1Grok 4.7

The diagnostics changed what models did next. On Signal Multiplexer22280, GPT-6.1 Sol’s first passing program took 294 cycles. Its profile showed node 2 working 86% of the time while nodes 1 and 3 spent 84% blocked waiting to write to it. GPT-6.1 Sol moved the branching out of node 2 and into those two neighbors. The next run took 204 cycles, 31% faster, at a cost of two more nodes and five more instructions.

The extra time behind those scores

Mean elapsed minutes per puzzle · same episodes

Standard episodeGod mode
Mean elapsed time across six matched puzzles0204060Opus 5.5: standard 13.34; god mode 55.85 minutes13.355.8Opus 5.5GPT-6 Astra: standard 13.35; god mode 60.01 minutes13.360.0GPT-6 AstraGPT-6.1 Sol: standard 13.35; god mode 60.01 minutes13.360.0GPT-6.1 SolGemini 4 Argon: standard 13.34; god mode 60.01 minutes13.360.0Gemini 4 ArgonGrok 4.7: standard 13.34; god mode 52.51 minutes13.352.5Grok 4.7

Information, tools, and time all changed together, so this study can’t say which addition helped most. These runs are outside the main leaderboard and the headline count.

Puzzles: Signal Multiplexer, Sequence Generator, Signal Edge Detector, Interrupt Handler, Sequence Peak Detector, and Signal Error Corrector.

Co-discovery

We submitted selected programs to the leaderboard, and the community improved on them almost immediately. On Undecimal Twin RounderSPEC44149538, @LongingForRest took Opus 5.5’s 1,918-cycle program and cut it to 1,744 by the next day. The record is now credited to both: LongingForRest/opus-5-5.

Neither got there alone. The models found new tradeoffs quickly, and players read those programs, worked out why they worked, and took them further.

Mathematics is seeing the same shift. Terence Tao and colleagues used LLM-guided search across 67 problems and improved on the best known results in several. In “After Math,” Silvia De Toffoli and Eamon Duede argue that a result only becomes a solution once mathematicians can understand it, and that AI fits better as an assistant than a competitor. TIS-100 is a small, measurable version of that future: a model finds a better program, and people turn it into something they understand.

Pareto explorer

Choose a puzzle and model, then select a point to see its scores and the program that produced it.

Pareto explorer

Lower is better ↙

Loading the frozen benchmark snapshot…
Community leaderboardModelNew frontier point
Select a point with the mouse or keyboard to inspect its scores.

The plot shows cycles and instructions; node counts can differ. New frontier points are judged on all three scores.

Download all 3,714 model Pareto points (CSV) · all 3,714 programs (ZIP) 186 rows are marked as new frontier points, which pool to 133 across models.

Methods

Expand

Suite. All 22 campaign puzzles, all 25 TIS-NET puzzles, and eight tournament puzzles from 2018: 19 easy (10 minutes), 17 medium (30), and 19 hard (45). Every model has one scored episode per puzzle. Time limits differ by difficulty, so difficulty and search time can’t be separated.

Scoring. Each model–puzzle pair contributes one selected attempt, with no best-of-attempts scoring, so solve rates are pass@1: a puzzle counts as solved when that one episode saved a program that replays in a fresh game. Unsolved puzzles stay in every average and score zero.

New frontier points. The reference is the community leaderboard as of October 15, 2026. Ties don’t count. Models found 154 candidate points on 23 puzzles. Our count pools and deduplicates them across models and keeps the 133 on 18 puzzles with fresh-game replay and 100,000 passing tests. Testing is strong evidence of correctness, not proof.

Record proximity. The community record divided by the model’s best score, averaged across the three scores and all puzzles, ×100. Each score can come from a different program.

Limits. One episode per pair compares the configurations as tested and doesn’t measure repeated-run variability. Spread between puzzles is variation across tasks. Public puzzles may overlap with training data. Mechanic groups are our own labels.

Programs. Every model Pareto point’s program is public under the MIT License, in TIS-100 save format and named like the community leaderboard’s files (<puzzle>.<cycles>-<nodes>-<instructions>.txt). Two points replay in the game but fail some random tests; they are included and never count as new frontier points.

Resources. Costs are estimated from recorded October 2026 API list prices, including cache discounts. Tokens accumulate across responses, so repeated input counts again, and tokenizers differ. Game calls count individual dispatched tools, including errors, and exclude the automatic final submission.

Settings by model

Run-early guidance adds a prompt note to test drafts early.

ModelReasoning effortRun-early guidance
Opus 5.5high14 / 55
GPT-6 Astrahigh3 / 55
Gemini 4 Argonhigh10 / 55
Sonnet 5.5high24 / 55
GPT-6.1 Solhigh3 / 55
Fable 5.1high23 / 55
Kimi K3.1 Proprovider default55 / 55
Gemini 3.8 Flashhigh0 / 55
Muse Wonder 1.0high55 / 55
Haiku 5.5high27 / 55
GLM-5.3provider default49 / 55
Grok 4.7medium: 9 · low: 4625 / 55
DeepSeek V4.1 Flashprovider default55 / 55
Muse Spark 1.3high55 / 55
GPT-6 Lunahigh2 / 55
MiMo-V2.6-Proprovider default53 / 55
Grok 4.7 episode counts are shown by effort. A sandboxed scripting tool for game calls was available in 46–54 of each model’s 55 episodes. A note about the game’s random test reached 841 of 880 episodes. 6 Opus 5.5 episodes and 5 Sonnet 5.5 episodes ran in a different agent client at the same effort.

Related work

ISA-Bench studies reasoning with constrained instruction sets, including TIS-100. Opus Magnum Bench tests agents’ ability to build and optimize machines in another Zachtronics game. We focus on optimization across all TIS-100 puzzles and eight community puzzles, keeping tradeoffs across cycles, nodes, and instructions. The tasks and protocols differ, so scores aren’t directly comparable.

Cite

@misc{wincon2026tis100bench,
  title  = {TIS-100 Bench: LLMs Push the Pareto Frontier in Programming Puzzle Games},
  author = {{Wincon}},
  year   = {2026},
  month  = nov,
  url    = {https://tis-100.wincon.dev/},
  note   = {Benchmark snapshot 2026-11-03-v5}
}

Credits

Thanks to Zachtronics, the TIS-100 players, and the maintainers of the community leaderboard, TIS-100-CXX, and leaderboard bot. Their solutions and tools make this comparison possible. Thanks also to @12345ieee, @LongingForRest, @Hersmunch, @easone, @18111398, and everyone on the Zachtronics Discord who discussed the submissions and kept improving them.

TIS-100, SpaceChem, and Opus Magnum are trademarks of Zachtronics. Model names and logos are trademarks of their respective owners and appear only to identify the models tested. Wincon Research is not affiliated with or endorsed by Zachtronics or any model provider.

Have a question or want to share feedback? Get in touch ↗