Queen: A 4B Language Model That Plays Chess at Master Level (2697 Elo) and Explains Its Moves

> Paper: Language Models that Play Chess and Explain Their Moves > arXiv: https://arxiv.org/abs/2610.03695 > Code: https://github.com/queen-project/queen

An Old Problem

In 1950, when Claude Shannon estimated the complexity of chess, he probably didn't anticipate an awkward situation 76 years later: strong engines can't talk, and talkative models can't play well.

Engines like Stockfish compute at over 3500 Elo, but ask them "why this move?" and they only output search depths and evaluation scores. Conversely, frontier models like GPT-5.6-Sol can write three hundred eloquent words analyzing a position, but actually play a full game with them and they may hang their queen by move ten.

The strong ones don't explain; the ones that explain aren't strong. This has long plagued the AI chess community.

In October 2026, Adithya Bhaskar, Jeffrey Cheng, and Danqi Chen (Princeton) proposed Queen (QUality Explanation and Evaluation Network), a 4B-parameter encoder-decoder model that does both: plays at master level (2697 Elo) and explains the reasoning behind every move in natural language.

Two Silent Components, One Speaking Whole

Queen's architecture draws inspiration from Flamingo (DeepMind's 2022 vision-language model), but replaces the "vision encoder" with a "board encoder":

• Encoder: The Lc0 neural network—a trained, silent chess engine with superhuman playing strength. It only "understands" positions; it doesn't speak.
• Decoder: An instruction-tuned language model (4B parameters). It speaks, but originally knows nothing about chess.
• The bridge: Cross-attention. Embeddings from layer *k* of Lc0 are injected via a Flamingo-style block before layer *2k* of the LM.

Training happens in two stages:

Stage One: QA Curriculum

The LM learns to "read" the board. The curriculum goes from static to dynamic:

• Static: Which pieces are attacked? How is king safety?
• Dynamic: If we play Nf3, how will the opponent most likely respond over the next three moves?

Through this curriculum, the LM learns to extract chess concepts from Lc0's representations—"center control," "kingside weakness," "piece coordination." At this point the model can explain positions, but its playing strength is only 1782 Elo (roughly intermediate amateur level).

Stage Two: Natural-Language Bellman Updates

This is the paper's cleverest part. Reinforcement learning has the Bellman update: \(V(s) = \max_a [R(s,a) + \gamma V(s')]\)—the value of the current position = the immediate reward of the best move + the value of the resulting position.

Queen moves this update into natural-language space:

1. The model generates several candidate moves for the current position 2. For each candidate, the model analyzes the resulting position ("if we play Nf3, the opponent's kingside weakens") 3. These analyses are integrated into an explanation of the current position 4. The explanation is distilled back into the model itself

Repeat 7 times. Each iteration, the model gets a bit stronger and its explanations a bit better. After seven rounds, Elo rises from 1782 to 2697—a gain of over 900 points.

The beauty of the "natural-language Bellman update" is that the model doesn't learn "is this move good?" directly; it learns "what will the position look like after this move?" The latter is more explainable, more transferable knowledge.

The Numbers

| Model | Params | Elo | Explanation quality (LM-scored) | |-------|--------|-----|-------------------------------| | Stockfish | - | 3500+ | None | | GPT-5.6-Sol | ~1T+ | ~2400 | High | | Gemini-3.1-Pro | ~1T+ | ~2200 | Medium-high | | Queen (initial) | 4B | 1782 | Medium | | Queen (after 7 iterations) | 4B | 2697 | Close to GPT-5.6-Sol |

Queen has three orders of magnitude fewer parameters than frontier models but outperforms them at chess. Its explanation quality (scored by an independent LM) approaches GPT-5.6-Sol's "high" level.

Why It Matters

1. The "Silent Expert + Fluent Explainer" Decoupled Architecture

Queen's core insight: playing strength and explaining ability are different capabilities that should be handled by different components, connected via cross-attention.

Lc0 handles the playing—it's already trained, no need to relearn. The LM handles the explaining—it already speaks; it only needs to learn to read the encoder's representations. Each does its job, and they reinforce each other.

This decoupled architecture generalizes: medical diagnosis (diagnostic model + explanation model), legal reasoning (retrieval model + argumentation model), code generation (execution model + commenting model). Anywhere there's an expert system that "can do but can't say," this framework can give it a voice.

2. Transferability of the Natural-Language Bellman Update

"Analyze candidate actions' consequences, integrate into an explanation, distill back into the model"—this loop isn't chess-specific. Any decision problem with a clear action space and evaluable outcomes fits:

• Go: analyze resulting positions from candidate moves, integrate into explanations
• Code generation: analyze execution paths of candidate implementations, integrate into comments
• Medical diagnosis: analyze examination results under candidate diagnoses, integrate into reasoning chains

The key: explanations are not decorative afterthoughts—they are the training signal itself. The model learns "to make the move" by "explaining why."

3. A Win for Small Models

Queen beats 1T+ parameter frontier models with 4B parameters. This proves: in vertical domains, a well-designed architecture plus domain-specific training signals can drastically reduce required parameter count.

Lc0's chess strength is "free"—already trained. The LM's language ability is also "free"—already trained. Queen only trains the cross-attention layers connecting them, plus iterative distillation to improve explanations. Training cost is far below training a 1T-parameter "do-everything" model from scratch.

Honest Limitations

The paper candidly admits:

1. Explanation quality still below GPT-5.6-Sol. Queen's explanations are "close to" but not exceeding frontier models. A 4B LM has real expressiveness limits. 2. Domain-specific. Queen only plays chess. The architecture transfers, but each domain needs its own encoder and QA curriculum. 3. Diminishing returns from iterative distillation. From round 5 onward, Elo gains clearly slow. Seven rounds may be near this framework's ceiling.

The Bigger Picture

Queen evokes a deeper truth: "being able to do" and "being able to explain" are two different intelligences.

Stockfish can do but can't speak; GPT can speak but can't do. Both are "half a person." Queen's contribution isn't "yet another chess AI" but stitching the two intelligences into a whole—using cross-attention to make the silent expert speak, and natural-language Bellman updates to make the speaking model speak more accurately.

This direction is more realistic and more explainable than "making one model do everything." After all, human experts work the same way—intuition (silent expert) + language (explainer), collaborating through some internal channel, refining iteratively.

The chess-playing machine Shannon envisioned in 1950 has finally arrived—except it not only plays, it tells you why.

---

Paper: https://arxiv.org/abs/2610.03695 Code: https://github.com/queen-project/queen