# maia-chess ships weights, not an engine, and the node limit has to be set to 1

> Nine Leela Chess neural networks trained to play the average move of a human at a given rating, where the practical instructions are one UCI option and a body to load them into, and where the successors to this work moved to separate repositories.

**CSSLab/maia-chess** — Maia is a human-like neural network chess engine trained on millions of human games.

- Repository: https://github.com/CSSLab/maia-chess
- Website: https://maiachess.com
- Stars: 1,253 · Forks: 151
- Language: Python
- License: GPL-3.0
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/csslab-maia-chess

## There is no move generator here, and searching must be switched off

The most important line of instruction is a negative one. These models are described as brains, meaning weights only, with no legal move generation, no evaluation of a position tree, and no opening book of their own. They need a body, and lc0 is the body named, with its own quickstart guide. Unlike most engines, you then want to disable searching, which means a nodes limit of 1. In UCI that is go nodes 1, and it is what makes the output look the way it does:

```
lc0 --weights=model_files/maia-1100.pb.gz
go nodes 1
Loading weights file from: model_files/maia-1100.pb.gz
info depth 1 seldepth 1 time 831 nodes 1 score cp 6 tbhits 0 pv e2e4
bestmove e2e4
```

A depth of 1 and a single node in the search line is the signature of a network making a single forward pass and returning the move it prefers. Leave the search running at defaults and you get a stronger but entirely different opponent, because the network's preference is then weighed against a search it was never trained for.

## The Lichess bots repeat themselves, so their opening books are unfinished

Three of the nine models are wired to accounts on Lichess, and the documentation is candid about the reason their opening books are still in development: the models play the same move every time. That is not a bug in the weights but the behaviour they were trained to produce, since a model trained on the average move of a rating class is by construction deterministic in its preferences. It does, however, create an unpleasant playing experience that has to be papered over, which is what the book is for. Until the books are finished, a regular opponent will see the same opening from the same bot and can prepare for it. The team says more bots will be added to the maia-bots team, and a fourth account, MaiaMystery, exists for testing new versions of Maia before they are given a rating.

## The models outplay their target rating, by design rather than by accident

There is a discrepancy worth stating plainly, because anyone benchmarking these weights will notice it. Each model is trained on games from a rating band, but the documentation notes that the models come out stronger than the rating they are trained on. The explanation given is that they make the average move of a player at that rating, and an opponent who always plays the average move of their level loses to almost anyone who sometimes plays better. So a 1100 model plays like a 1100 player in the sense that its choices look like that level's choices, while its results read higher than the label suggests. Anyone using the targeted rating to pick a training opponent should expect to lose more often than the number implies, and anyone using these models to benchmark strength should not treat the label as a rating estimate.

## Nine weights files exist, and three of them have bots

The repository holds nine final models saved as Leela Chess neural networks, spanning a range from ELO 1100 to 1900. Three are downloadable as individual release assets with Lichess accounts attached: maia-1100.pb.gz as maia1, maia-1500.pb.gz as maia5, and maia-1900.pb.gz as maia9. The other six have no bot, covering 1200, 1300, 1400, 1600, 1700, and 1800, and are downloadable the same way. Every model is also present in the maia_weights folder inside the repository, so cloning is enough for a local run and the release assets only matter if you want the file without the code. All of them come from a single tagged release, v1.0, published on 2021-01-14 and named as the KDD paper code release.

## Maia-2 and Maia-3 moved to their own repositories

The work has continued, and the successors are not in this repository. Maia-2 is presented as a unified model that coherently captures human play across skill levels rather than one model per level, with a NeurIPS 2024 paper and code in a separate maia2 repository. Maia-3 is newer still and changes the architecture rather than the training set: it is described as built with a Chessformer architecture and as outperforming the earlier models with significantly fewer parameters, with an ICML 2026 paper, weights published on Hugging Face under the UofTCSSLab organisation, and code in a maia3 repository. The practical consequence is that this repository is the one to read for the training pipeline, the datasets, and the original nine models, while anything newer has to be fetched elsewhere.

## Training your own model needs two external tools on the PATH

The pipeline is five steps and two of them depend on programs that are not part of the repository. You put pgn-extract and trainingdata-tool on your PATH, then run move_prediction/pgn_to_trainingdata.sh with an input PGN path and an output path. The documentation warns that the processing is both IO and CPU intensive, and that you should wait. The script produces a training set and a validation set, and to train on everything you copy the files from the validation folder into the training folder yourself. Configuration happens in move_prediction/maia_config.yml, where you point input_train at the training glob, input_test at the validation glob, and optionally change the gpu field if you have several. Training is then move_prediction/train_maia.py with the config path, tensorboard logs land in a directory named after the config, and the final model is whichever checkpoint has the largest number.

## The replication scripts have no flow control, so they run one line at a time

Reproducing the published models is a longer path than training your own, and the documentation sets expectations accordingly. It starts from raw Lichess database files for the period January 2017 to November 2019, which are downloaded into a data directory, then a generation script produces the PGNs, then the same training data conversion and training steps apply. The warning is about ergonomics rather than correctness: the scripts contain no flow control logic, so running them manually line by line may be necessary. Anyone automating this should know that in advance rather than discovering it when a script silently continues past a step that should have stopped. The shuffling and game selection logic, which is the part that actually reproduces the paper's data split, lives in its own file, replication-move_training_set.py, rather than being distributed across the shell scripts.

## The published data is Stockfish-analysed CSV, not raw database dumps

The analysis behind the models used games that had already been evaluated, and that intermediate data is what gets released. Every game on Lichess with Stockfish analysis was processed into CSV files, and those are hosted as the maia_kdd dataset. Two things follow for anyone planning to reproduce the work. First, the per-move evaluation values that training depends on are not something you can derive quickly from a fresh download of the Lichess database, since computing them is the expensive part and the released CSVs skip it. Second, the volume is not trivial, so the download is a real step rather than a formality. The repository also keeps the environment definition in maia_env.yml for a conda setup, and the requirements file lists numpy, python-chess, pytz, humanize, tensorboard, tensorflow, protobuf, tensorboardx, seaborn, and matplotlib.

## Conclusion

maia-chess fits someone who wants opponents that make recognisably human mistakes at a chosen strength, and who is already willing to run lc0 or would rather just play the bots on Lichess. It does not fit someone expecting an engine that starts and plays on its own, because there is no move generator here at all. Before using it, set the node limit to 1 rather than leaving the search on, decide whether you want the trained models or the successors, since Maia-2 and Maia-3 are in other repositories, and read the licensing terms if you plan to redistribute the weights.

## FAQ

### how to install maia chess engine

There is no engine to install: the repository holds neural network weights in Leela Chess format. Download a .pb.gz file from the v1.0 release or the maia_weights folder, load it into lc0, and set the node limit to 1 with go nodes 1. The easiest route needs no installation at all, since three of the models play on Lichess as maia1, maia5, and maia9.

### is maia chess open source

The repository is licensed GPL-3.0 and contains both the code to create new models and the nine final trained models. The analysis datasets, processed from Lichess games with Stockfish analysis into CSV files, are published as well.

### how strong is maia chess

The nine models target ELO 1100 through 1900, one per rating band. The documentation notes they are actually stronger than the rating they are trained on, because they play the average move of a player at that level.

### how to use maia chess

Load the weights into lc0 following its quickstart, then disable searching with a node limit of 1 so the network's single forward pass decides the move. To drive the models from Python instead, the LeelaEngine class in move_prediction/maia_chess_backend reads the config files in move_prediction/model_files and wraps python-chess.

## Sources

- [CSSLab/maia-chess on GitHub](https://github.com/CSSLab/maia-chess)
- [License: GPL-3.0](https://github.com/CSSLab/maia-chess/blob/master/LICENSE)
- [Project website](https://maiachess.com)
- [README](https://github.com/CSSLab/maia-chess/blob/master/README.md)
- [Releases](https://github.com/CSSLab/maia-chess/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/csslab-maia-chess