Superseded: this model is from an earlier Jeff release and is no longer updated. The current Jeff release is Jeff v1.3: mstrasser/jeff-base.
Jeff-Qwen3.5-0.8B-Chess
A chess fine-tune of Jeff-Qwen3.5-0.8B: it looks at a position once and gives every legal move a probability, in about 23 ms, with no search. We made it to show what the Jeff models are for: a small, fast decision model that you fine-tune on your own task when zero-shot isn't enough. A few hours of training on one GPU took it from 15.5% to 55.8% on held-out chess puzzles.
It is not a strong chess player. It plays at roughly 1,000 Elo on Stockfish's scale and loses to Stockfish's weakest setting. What it shows is how far a short fine-tune moves a 0.8B decision model, and how fast such a model is: one GPU keeps up with about 600 blitz games at once.
Why this model exists
We released it for three reasons:
-
To show the progression of one 0.8B model, in three steps. Untrained Qwen3.5-0.8B is barely better than random at choosing a chess move (6.2% of puzzles, against 5.1% for a random legal move). Our general decision training, which contains no chess, makes it Jeff-Qwen3.5-0.8B (15.5%). Training on chess positions makes it Jeff Chess (55.8%).
-
To show that Jeff has real zero-shot ability, when the problem is presented the right way. With no chess training at all, Jeff solves 15.5% of the puzzles when the board is given in FEN, the standard chess notation: three times random, and 2.5 times the model it started from:
Held-out puzzles solved (board given in FEN) Random legal move 5.1% Qwen3.5-0.8B, untrained 6.2% Jeff-Qwen3.5-0.8B, zero-shot (no chess training) 15.5% Jeff-Qwen3.5-0.8B-Chess (trained on chess positions) 55.8% This is the same lesson as in our game tests: describe the situation in a form the model can read, and its judgement shows. Zero-shot is not yet good chess, since a two-line rule (play mate, else a capture or check) solves 37.9%; that is where a short fine-tune comes in.
-
To show what decisions in milliseconds make possible. Jeff reads a situation and weighs every option in a single pass, in tens of milliseconds, with no text generation. That turns judgement into something software can call as often as it calls any other function: here, one GPU keeps pace with about 600 human blitz players at once, while each opponent is still thinking. The same speed applies to the everyday cases Jeff is built for, such as routing messages, reading documents, or understanding voice commands, wherever a decision has to happen in real time.
100 games at once on one RTX PRO 6000, in real time (recorded with an earlier training round of this model). Left: game 63, Jeff's one win out of the 100, a nine-move checkmate, with Jeff's top three moves and their probabilities at each turn; the opponent takes seconds per move, Jeff tens of milliseconds. Right: the other 99 games. The opponents are Stockfish at its weakest setting (UCI_Elo 1350), each move delayed by a human think time sampled from real Lichess blitz games. Over all 100 games Jeff won 1, drew 30 and lost 69.
Puzzles
1,000 held-out Lichess puzzles (the model's top move must be the puzzle's first solution move), by puzzle rating:
| Model | All | Under 1000 | 1000–1499 | 1500–1999 | 2000+ |
|---|---|---|---|---|---|
| Random legal move | 5.1% | 4.3% | 5.0% | 5.5% | 5.8% |
| Qwen3.5-0.8B, untrained | 6.2% | ||||
| Jeff-Qwen3.5-0.8B (zero-shot, no chess training) | 15.5% | 31.6% | 13.6% | 8.8% | 8.0% |
| Simple rule: mate, then captures and checks | 37.9% | 64.0% | 40.7% | 25.1% | 21.7% |
| Jeff-Qwen3.5-0.8B-Chess | 55.8% | 86.4% | 62.0% | 40.4% | 34.4% |
The simple rule is a strong baseline because standard move notation already marks captures (x) and checks (+). Jeff Chess beats it by 13 to 22 points in every band. The 95% interval on its 55.8% is 52.7–58.9%.
Playing games
| Opponent (20 games each) | Wins | Draws | Losses |
|---|---|---|---|
| Stockfish, UCI_Elo 1350 | 0 | 0 | 20 |
| Stockfish, UCI_Elo 1600 | 0 | 3 | 17 |
| Stockfish, UCI_Elo 1900 | 0 | 1 | 19 |
Estimated rating: about 1,000 on Stockfish's UCI_Elo scale, clearly below its weakest setting. Every draw was a threefold repetition. For comparison, Jeff-Qwen3.5-0.8B without chess training went 0–1–19 against Stockfish 1350.
Speed
- 23 ms per move on an RTX PRO 6000; about 43 ms on an Apple M4 Max (MLX), measured through a web app.
- With batching, one RTX PRO 6000 sustains 214 moves per second while keeping 95% of answers under 200 ms.
- Human blitz players take a median 3.0 seconds per move (20,000 recent Lichess blitz games). So one GPU could keep up with about 214 × 3.0 ≈ 640 games at once; we say about 600. In a real run of 100 games at once, Jeff answered 3,742 moves at a median of 40 ms (95th percentile 74 ms).
How it was trained
- Start: Jeff-Qwen3.5-0.8B, full-weight fine-tune at learning rate 5e-6 on one RTX PRO 6000: two stages of one epoch each on different positions, about 3 hours 20 minutes in total.
- Data: 600,000 positions, all public domain (CC0): 270,000 from the Lichess puzzle database, spread across ratings, and 330,000 from Lichess games (skipping the first 8 moves; the later stage from games where both players are rated 1800 or more). No puzzle or game is shared between training and the test sets.
- Labels: Stockfish 19 scored every legal move at depth 10. Each score becomes a win probability (Lichess's formula), and a softmax at temperature 0.02 turns those into the target probability for each move. So the model learns a calibrated spread over moves, not just the single best one.
- Board format: FEN, the standard chess notation.
Request format
Each request is the position in FEN and every legal move, in standard algebraic notation, as an option:
{"model": "jeff", "state": {"fen": "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"},
"questions": {"move": {"type": "choice",
"instructions": "You are playing white. Choose the best move in this position. The position is given in Forsyth-Edwards Notation (FEN).",
"criteria": {"Na3": null, "Nc3": null, "Nf3": null, "Nh3": null, "a3": null, "a4": null, "...": null}}}}
Build it exactly this way: the FEN as python-chess writes it (an en passant square only when the capture is legal),
the two instruction sentences word for word, and the moves as python-chess writes them in SAN, sorted in plain
character order. Serve it with the Jeff code (jeff-serve).
Caveats
- No search, no plan. Each move is one look at the current position. It can repeat positions and draw won games, and it misses deeper tactics.
- A chess specialist. Chess training costs general ability, so use Jeff-Qwen3.5-0.8B for anything other than chess.
- At most 101 options. The largest training position had 101 legal moves, so the server refuses positions with more
(
max_optionsindecision_config.json). Such positions are very rare in real games. - Our own measurements. The puzzle set, games and speed tests are ours; the details and commands are in the Jeff repository.
Licence
Weights: Apache 2.0 (from Qwen3.5-0.8B by the Qwen team, Alibaba Cloud, via Jeff-Qwen3.5-0.8B). Training positions: the Lichess puzzle and game databases (CC0). Stockfish (GPL-3.0) was used only to score moves; it is not part of the model.