Results
Seed-1 evaluation tasks the model never trained on, temperature 1.0, the model's own reasoning only. Every solve is confirmed by replaying its moves on the cube engine.
Table with columns: test, solved| test | solved |
|---|
| real scramble → solved, end to end | 42 / 64 tries (66%) |
| … solved in at least 1 of 2 tries | 28 / 32 scrambles (88%) |
| whole last layer (F2L already solved) | 60 / 64 (94%) |
| full F2L (cross already solved) | 31 / 32 (97%) |
| 6-move crosses | 25 / 32 (78%) |
All 22 failed full solves were stopped by the evaluation's limits (12 ran out of 30 turns, 10 hit a 120-move cap), not by the model getting stuck. A solve takes a median of 85 moves in 22 tool calls. play.py uses 200 moves and 40 turns by default.
For reference, the base Qwen3.5-9B solves almost no crosses, and in CubeBench every frontier model tested scored 0% on scrambles 8+ moves from solved without a solver tool.
How it solves
It follows CFOP, as a speedcuber would, and every step of its reasoning is a lookup rather than a search:
- Cross. It copies the edge squares, names each white edge from the square it touches, lists one move per edge that brings it a step closer (and whether that move keeps the finished edges safe), then picks one. One move per call.
- F2L. For each pair it either extracts a stuck piece, sets up the corner with a top-layer turn, or names the case. It reads every case as if the slot were at front-right (one table of 59 algorithms instead of 236), then swaps the face letters back for the real slot. One algorithm per call.
- Last layer. Two-look OLL and PLL (16 algorithms, all in face moves): it names the pattern, then the case and the top-layer turn before its algorithm, then a final turn to line up the top.
Each reply in a full solve starts with Stage: cross, Stage: F2L or Stage: last layer.
Training
LoRA SFT on engine-written reasoning traces (every line checked against the cube), plus GRPO-style RL on the cross, with prime-rl and verifiers. The stages were trained one after another, each run starting from the previous model, and the weights here are all of them merged into the base:
Table with columns: model, adds, trained with| model | adds | trained with |
|---|
| v3 | reading the cube; the cross at 1-4 moves | SFT |
| v4 | the cross at 3-8 moves | RL, exact-distance reward |
| v5 | choosing cross moves by lookup | SFT |
| v6 | the cross on real scrambles (75.9%) | RL |
| F3, F4 | F2L by case lookup, then the 59-case FR view | SFT |
| F5 (this model) | the 2-look last layer and whole solves | SFT |
Use it
The model expects the exact environment it was trained in: the system prompt in system_prompt.txt, the tools in tools.json, and the cube as six 3×3 grids of color letters (U R F D L B; white on D, yellow on U, green on F). play.py is that whole environment in one file. Its cube uses the training engine's move tables (moves.json), and its tool replies are identical, character for character, to the environment's on the 28 recorded solves.
pip install vllm openaivllm serve arjanssuri/qwen3.5-9b-rubiks-cube --max-model-len 32768 \ --enable-auto-tool-choice --tool-call-parser qwen3_coderpython play.py --base-url http://localhost:8000/v1 --model arjanssuri/qwen3.5-9b-rubiks-cube
Keep thinking off (chat_template_kwargs: {"enable_thinking": false}, as play.py does) and sample at temperature 1.0, as in training and evaluation.
Limits
- One orientation. It was trained with white on the bottom and green in front, and it reads the cube that way.
- One format. Prompts, tools and cube text other than the ones above are untested.
- Weak spots: about 1 in 5 six-move crosses fail, and among PLL cases it fumbles the H and Z perms about half the time.
- Long episodes. A full solve is about 14K tokens of conversation.