Frontier · next-concept modelling · Stanford / Hazy Research, October 2026 · reproduced 24 October 2026
A 25-million-parameter model against the chat leaders
Chat models write one word-piece at a time. Next-concept modelling sketches the whole answer first, then sharpens it in a dozen parallel steps. I ran Stanford's released model on my laptop's CPU and gave it the same hard Sudoku boards as the chat models.
Part of Work · What's next
In October 2026 Hazy Research at Stanford released a new way to generate text. The model drafts a rough code for the whole answer, then refines all of it together, level by level. To see how it compares with the big chat models, I moved their small Sudoku model from NVIDIA GPUs to my laptop's CPU and wrote a harness that gives each chat model the same boards.
On 50 hard boards it solved 40, in under half a second each. Claude Opus 5.5 solved 46 and took nearly a minute per board.
Terms used here
- Parameters
- The numbers a model learns. More of them usually means a more capable model that is slower and costs more to run.
- Token
- A piece of text a model reads or writes, often part of a word. A Sudoku board here is 89 tokens.
- Autoregressive
- Writing one token at a time, each depending on the last. This is how today's chat models generate.
- Diffusion language model
- A model that starts from a blank or noisy answer and improves all of it over many rounds.
- Next-concept modelling (NCM)
- Generating coarse to fine. A short, rough code for the whole answer comes first, then longer and more detailed codes, with all positions in a level written together.
- Function evaluation (NFE)
- One pass through the model. NCM solves a board in 12, one per level. A chat model needs at least one per token it writes.
- Reasoning model
- A chat model that writes a long hidden chain of thought before answering. It helps on puzzles and costs time.
The idea
Coarse to fine, in parallel
A tokenizer, trained first and then frozen, turns a whole answer into a stack of codes: one code at the top, then 2, 4, 6 and so on up to 89 at the bottom, one per cell and row break. Each level adds detail to the one above. The generator predicts the stack from the top down, all positions in a level together, so a board takes 12 passes through the model however many cells are empty.
A chat model works the other way round. It writes one token per pass, left to right, and a reasoning model writes thousands of hidden tokens before the 81 digits it was asked for. That is where the minute per board goes.
Same 50 boards
hard set, boards 1 to 50
| Model | Where it ran | Solved | Time per board |
|---|---|---|---|
| NCM, Sudoku hard (25M parameters) | my laptop's CPU | 40 of 50 | 0.47 s |
| Claude Opus 5.5 | Anthropic, through my subscription | 46 of 50 | 53 s (median) |
| Claude Sonnet 5.5 | Anthropic, through my subscription | 32 of 50 | 54 s (median) |
All the chat models got the same prompt: the board as nine rows with dots for blanks, and a request for the nine completed rows between ANSWER and END. An answer counts only if it matches the reference solution exactly. Times are wall-clock per board, one board per request; the chat models' include the network. NCM's is measured the same way, one board at a time, after an 11-second one-off model load; in batches of 100 it does 0.26 s per board.
The other parallel idea
diffusion language models
Diffusion models need many steps
Diffusion language models also write the whole answer at once. They start from a blank answer and improve all of it over a number of rounds, called steps. Fewer steps should mean faster answers. I ran two open ones, Dream 7B and LLaDA 8B, on the laptop's GPU and compared them with Qwen2.5 7B, the ordinary model Dream was built from, on the same question.
| Model | Steps | Time | The answer |
|---|---|---|---|
| Qwen2.5 7B, one token at a time | 105 tokens | 3.8 s | Correct and fluent |
| Dream 7B, diffusion | 32 | 11 s | Word salad: "token number is token a smaller of is…" |
| Dream 7B, diffusion | 128 | 48 s | Mostly readable, with stutters |
| Dream 7B, diffusion | 256 | 124 s | Fluent, partly right |
| LLaDA 8B, diffusion in 32-token blocks | 64 | 16 s | Readable, drifts off topic |
| LLaDA 8B, diffusion in 32-token blocks | 256 | 64 s | Fluent, partly right |
With fewer steps than the answer has words, the text fell apart. Fluent text needed about one step per word, and by then the speed advantage was gone: on this laptop the ordinary model gave a better answer 17 to 33 times sooner. llama.cpp's diffusion code is a reference implementation that recomputes the whole answer at each step, so optimised serving on datacenter GPUs is much faster. The link between steps and quality still holds.
Next-concept modelling goes after that trade-off. It uses a dozen levels, from a one-code sketch to the full board, and the early levels are short and cheap.
Reading the result
What the comparison shows
- NCM is a specialist. This model was trained only on Sudoku and can do nothing else. The chat models were never trained for this task and can do almost anything.
- The question is fit. The strongest general model was the most accurate: Opus solved 46, NCM 40, Sonnet 32. NCM got there in half a second on a laptop CPU with 25 million parameters, while the datacenter models took about a minute per board. For a task with a fixed structure and plenty of examples, a small specialist is often the better trade.
- The chat models had no tools. With a code interpreter any of them could write a solver. Here each model works on its own.
- 50 boards is a small sample. The gaps between 46, 40 and 32 are clear, and the exact percentages would shift with more boards. On the full set of 500, NCM solves 85.2%.
Method
How it was run
- Released weights and code from Hazy Research (MIT licence), the Sudoku easy, medium and hard checkpoints and their test boards.
- Moved off NVIDIA GPUs. The evaluation script assumed CUDA; I made the device selectable and ran on the laptop's CPU (AMD Ryzen AI Max+ 392). The model's own results are unchanged: 99.2% easy, 97.6% medium, 85.2% hard on 500 boards each. Timings were taken on mains power.
- Loaded safely. The original code loads model files in a mode that can run code hidden in them. I checked that the files load in PyTorch's safe mode, switched the code to it, and confirmed that the data files hold only plain data.
- Diffusion runs with llama.cpp's diffusion example, built with Vulkan for the laptop's Radeon 8060S: Dream 7B and LLaDA 8B against Qwen2.5 7B, all at 8-bit, greedy, same prompt and seed. All outputs are saved.
- A benchmark harness in Python that sends each board to each model, retries on rate limits, checks each answer against the solution and saves results as they arrive.
PyTorch · Python · Hugging Face · OpenRouter