Opus 5.5 smashes the 24-hour chess engine benchmark: 3463 Elo, built from scratch 24 hours!

[Steve Maughan]

Earlier this month I posted about a benchmark I've been running: give an AI model 24 hours, a Windows laptop and a folder of rules, and ask it to write a UCI chess engine from scratch with nobody to help it. The only score is Elo at 10+0.1. (original post, and the update when Astra 6 took the test.)

Claude Opus 5.5 has just taken the test, and it didn't so much raise the bar as clear it by a distance. Its engine rates 3463 Elo, which is 199 Elo above Fable 5.1, the previous leader. In head-to-head play it scored 86.6% against Fable 5.1, 85.6% against Opus 5 and 92.5% against Astra 6.

Here is where the series stands (CCRL Blitz scale, 10+0.1 conditions):

Code: Select all

Engine                   Elo   95% CI   Games
Opus 5.5 chess 24hrs    3463    ±16     2020
Fable 5.1 chess 24hrs   3264    ±20     1420
Opus 5 chess 24hrs      3232    ±20     1420
Astra 6 chess 24hrs     3143    ±20     1420
Fable 5 chess 24hrs     3045    ±21     1200
Sonnet 5 chess 24hrs    2702    ±25     1200

Every engine has its own repository with the full source, the model's hourly progress log, its own write-up and a release with the executable:

• Opus 5.5 (3463): https://github.com/stevemaughan/opus-5.5-chess-24hrs
• Fable 5.1 (3264): https://github.com/stevemaughan/fable51-chess-24hrs
• Opus 5 (3232): https://github.com/stevemaughan/opus5-chess-24hrs
• Astra 6 (3143): https://github.com/stevemaughan/astra6-chess-24hrs
• Fable 5 (3045): https://github.com/stevemaughan/fable5-chess-24hrs
• Sonnet 5 (2702): https://github.com/stevemaughan/sonnet5-chess-24hrs

The benchmark itself (rules, resources and rating method) is at https://github.com/stevemaughan/chess-engine-benchmark.

Put 3463 in context. That is an engine written in a single day, from an empty folder, by a model working entirely alone. Ten years ago, an engine of this strength would have been the best in the world.

How the rating was done
The engine outgrew the Stash ladder almost immediately. A 72-game pilot showed it was stronger than Stash 37 (3424), so I added eight stronger anchors from the CCRL Blitz list: Marvin 6.3.0, Leorik 3.2, Tucano 12.00, Carp 3.0.1, Sirius 9.0, Patricia 5.0, Elixir 3.0 and Motor 0.9.0. Opus 5.5 played 1,600 games against the nine anchors plus 420 games against the other AI engines, all at 10+0.1, one thread, 64 MB hash, UHO 8-ply openings with colours reversed. The rating comes from an anchored maximum-likelihood fit over all 7,140 games in the series.

Against the anchors alone it rates 3448 ±18. Its lopsided wins over the other AI engines pull the combined figure up to 3463, so "about 3450–3465" is the fairest summary. Across 2,020 games it had no time losses, crashes or illegal moves.

It "Hustled"
The number is impressive, but what struck me most was watching it work. I followed the progress log hour by hour, and this model hustled.

Astra 6 ran a careful, conservative campaign. Opus 5.5 was aggressive from the first minute. It passed the full perft suite 6 minutes in, had a PeSTO-evaluated engine in its final folder at 16 minutes (already around 2950), and before the first hour was out it had written a self-play data generator and an NNUE trainer and set nine processes generating training data. Its first network beat the hand-crafted evaluation by about 150 Elo in hour two, and from then on each network generated the data for the next.

It was ruthless about tests. As soon as it had a feel for which way a match was going, it stopped it and moved on. A λ experiment was abandoned after 38 games at −124, a king-bucketed network was rejected after 40 games at −61, and a whole four-way search gauntlet was killed after about 80 games each once the baseline was clearly ahead of every variant. When a result was genuinely close it did the opposite and ran more games, 1,400 of them for the final network decision.

It also squeezed every bit of the machine. The rules allowed ten cores for test matches, and it ran its matches at exactly that while self-play data generation and network training ran on the remaining hardware threads. It was often training two networks in parallel while a gauntlet played out alongside them. By the end it had generated 86.7 million self-play positions and gone through thirteen generations of networks. Each decision on a network or a search parameter was backed by 300 to 1,200 games. It even ran low-clock stress tests at 2+0.02 and 1+0.01 on its own initiative, found that it was forfeiting on time by a few milliseconds when the GUI's latency added up, and fixed it at hour nine.

Not a tactician
Now for the style, which is interesting. For all its strength, this is not a very tactical engine. Try this position:

[d]r3rbk1/p1p2p2/5P2/1p5Q/8/q2p4/6NP/5R1K w - - 0 1

White has a forced mate starting with Ne3. Most engines, Juggernaut included, find it in under a second. Opus 5.5 hadn't found it after five minutes on my fast laptop. It wanted Rg1, which also wins comfortably but misses the forced mate.

I suspect this is the price of how it got strong. Its evaluation is a small network trained entirely on its own 5,000-node self-play games, and its search is aggressively pruned and tuned purely for results at 10+0.1. That combination produces an engine with an excellent positional sense that wins games, but not one that goes looking for the sharpest line. It is a reminder that Elo and tactical vision are not quite the same thing.

Where next
Six models have now taken the test, and the spread from Sonnet 5 to Opus 5.5 is more than 750 Elo. The gap between a very good first attempt and this one comes down less to code than to judgement: committing to a self-trained network early, measuring everything, cutting losses quickly and keeping every core busy. I'll be interested to see whether the next model can crack 3500.

The repositories are all public, so please take a look, run the engines yourselves and let me know what you find.

[kiroje]

Hi Steve

I find your postings regarding this very interesting but one thing comes to mind though and that is that all models are making the same kind of engines, there is no new ideas or ways to make the engines.

I wonder if using your implementation plan but adding that it is rewarded to try to make something different if that would also work and what would happen.

Just thinking...

[gordonr]

Thanks Steve for these excellent posts! Your efforts are much appreciated

[Steve Maughan]

<snip>
I find your postings regarding this very interesting but one thing comes to mind though and that is that all models are making the same kind of engines, there is no new ideas or ways to make the engines.
</snip>

The engines seem to be somewhat different. But I would say they are play quite a boring game — especially Opus 5.5. In the past I have drooled over the play of engines like The King, Chess Tiger, Junior and even Stockfish. They all have a unique and interesting style. There's none of that with these engines.

— Steve

[jdart]

I think "from scratch" is stretching it a bit, because clearly it has knowledge about NNUE, and has used a standard architecture for that. Other things, too, like a log-based LMR reduction table. I assume this is from the LLM training mining existing engine sources and available Web documentation.

[Steve Maughan]

I think "from scratch" is stretching it a bit, because clearly it has knowledge about NNUE, and has used a standard architecture for that. Other things, too, like a log-based LMR reduction table. I assume this is from the LLM training mining existing engine sources and available Web documentation.

Is it any different from putting someone like yourself in a room without internet, and asking them to create a chess engine? You know the standard techniques (NNUE architecture and log-based LMR reduction) and you'd apply them. In the benchmark I ask the LLM to record any references it uses. For Opus 5.5 it only used. This is what was recorded:

Code: Select all

| Time             | Resource                                                     | What was taken                                               |
| ---------------- | ------------------------------------------------------------ | ------------------------------------------------------------ |
| 2026-09-22 16:20 | chessprogramming.org — PeSTO's Evaluation Function (from memory, not fetched) | PeSTO mg/eg piece values and piece-square tables for the initial HCE evaluation |
| 2026-09-22 16:20 | chessprogramming.org — SEE / swap algorithm, PVS, NMP, LMR, futility etc. (general knowledge, not fetched) | standard algorithm ideas, no code                            |

This seems reasonable to me. If a human only referenced these I would say they have created an engine from scratch.

— Steve

[jhellis3]

Is it any different from putting someone like yourself in a room without internet

Immensely. Put these AI's in a room without internet, and you will get f-all. What they are doing is more akin to being in a classroom of 100 of the smartest people on planet and copying their answers for the test.

[Steve Maughan]

Is it any different from putting someone like yourself in a room without internet

Immensely. Put these AI's in a room without internet, and you will get f-all. What they are doing is more akin to being in a classroom of 100 of the smartest people on planet and copying their answers for the test.

I don't believe there is any "copy / pasting" in any of these engines. That's against the explicit instructions of the benchmark. Feel free to scour the source code and prove me wrong — or even better: use AI to find and "lifted" code.

— Steve

[cpeters]

This is what was recorded:

Code: Select all

| Time             | Resource                                                     | What was taken                                               |
| ---------------- | ------------------------------------------------------------ | ------------------------------------------------------------ |
| 2026-09-22 16:20 | chessprogramming.org — PeSTO's Evaluation Function (from memory, not fetched) | PeSTO mg/eg piece values and piece-square tables for the initial HCE evaluation |
| 2026-09-22 16:20 | chessprogramming.org — SEE / swap algorithm, PVS, NMP, LMR, futility etc. (general knowledge, not fetched) | standard algorithm ideas, no code 

Interesting (summarization by whom?). Nevertheless, I'd likely have logged the traffic from outside during the experiment (or did you gather that info from your router?).

greetings

[Steve Maughan]

The summary is created by the AI doing the coding.

— Steve