Next-Concept Modeling (NCM) Explained: Is Stanford's 32-Pass AI the End of LLMs? We Ran It on a MacBook

Every chatbot you've used writes one word at a time, so a 1,000-word answer means about 1,000 trips through the model. A Stanford paper called Next-Concept Modeling (NCM) sketches the whole answer first and sharpens it in a handful of passes: 32 instead of 1,024 in the paper's web-text test.

People are calling it the end of LLMs. It isn't. We read the whole paper, then ran the released model on a MacBook. Here is how it works, where it wins, where it still loses, and whether Nvidia should be worried. The honest answer is more interesting than the hype.

Why AI is so hungry for memory

ChatGPT, Claude and Gemini all write the same way. The model looks at everything so far, guesses the next word, adds it, and starts over.

Here's the part most people miss. On every one of those trips, the chip has to pull the entire model out of memory. Billions of numbers, a thousand times over. Think of a chef who walks to the warehouse for every single ingredient. The cooking is fast. The walking is the problem. So the most powerful chip in the world spends most of its time waiting for memory.

It gets worse in long chats. The model keeps a running notepad of everything said so far, called the KV cache, so it doesn't have to reread the whole conversation each time. That notepad grows with every word, and it lives in the same memory.

That's why Nvidia's AI chips come wrapped in a special kind of memory called high-bandwidth memory (HBM). It's stacked right next to the chip, so the walk is shorter. It's also hard to make, and memory factories are shifting so much production to it that the regular memory in laptops and phones got scarce and expensive. Dell's chief operating officer said he had never seen costs rise at this pace.

So the real question: what if the AI didn't need a thousand trips? What if it could write the whole answer in about thirty?

Isn't this just diffusion?

If you follow AI closely, you've seen something like this. Diffusion language models, such as Google's Gemini Diffusion and Inception's Mercury, borrow the trick from image generators. Start with a page full of blanks and fill them all in together, a little more each step.

The paper isn't pretending those don't exist. Diffusion is exactly what it's trying to beat, and it names three problems:

1. Lots of steps. Cut the steps and the writing falls apart.
2. No notepad. Every step rereads the entire page, so it can't keep that handy KV cache.
3. Huge training sets. The best ones are trained on more than five hundred billion words of text.

How NCM works

Instead of filling in blanks, NCM works like a painter. A painter doesn't paint a portrait one eyelash at a time, left to right. First comes a rough sketch of the whole face. Then the shapes, the shadows, and finally the eyelashes. Every pass covers the entire canvas, and every pass only fixes what the last one got wrong.

NCM does this with text, in two parts.

Part one: the compressor

It learns to describe a sentence in layers. The top layer is just a few codes, the gist, like "a dog on a beach." The next layer adds what was missing: golden retriever, sunset. Each layer stores only the correction. Stack the layers back up and you get the original sentence back, word for word, 99.99% of the time on web text.

Part two: the writer

This is where the speed comes from. The writer predicts the layers from the top down. One pass for the gist, one pass for the next layer, and inside each layer every position is filled at the same time. So the number of passes depends on how many layers there are, not on how many words you want.

The two training tricks

• Nested dropout. During training, they randomly cut away the bottom layers. Sometimes the model only gets the top two layers to rebuild the whole sentence, so the top layers are forced to carry the main idea. It's like being told to sum up a film in three words. You learn fast which three words matter.
• Conditioning corruption. If the first sketch is wrong, every layer after it builds on a mistake. So they deliberately feed the writer sketches with wrong codes mixed in, and still ask for the right answer. The model learns to repair a bad sketch instead of trusting it. Like a GPS that recalculates when you miss a turn.

There's a bonus. Because each answer is so cheap, you can write several at once, compare them, and keep the one most of them agree on. On news summaries, that pushed NCM past the best competitor in the paper.

We ran it on a laptop

Stanford released the code (MIT license) and the trained models for free. We downloaded the Sudoku model and ran it on a MacBook Pro with an Apple M4 Pro. No Nvidia GPU, no cloud.

Why Sudoku? It's the perfect trap for word-by-word AI. Every cell depends on its row, its column and its box. Fill it in left to right, get one cell wrong early, and you can't go back. In the paper's Table 3, a word-by-word model of the same size (25 million parameters) solved 1% of the hard puzzles.

Same result as the paper, on a laptop. We also watched one board fill in pass by pass. After the first pass, 15 cells were right. Then 27. Then 54. Twelve passes in, all 81. It even got worse for a moment, then fixed itself. That's the second training trick at work.

The honest scorecard

To be fair, Sudoku is the best case for this idea, because the whole board has rules that must fit together. So here's the scorecard for actual writing.

NCM also learned from about five times less training data than the diffusion rivals.

The catch

Now the part the hype skips.

• The speed numbers are not against ChatGPT. "21, 10 and 31 times faster" are the authors' comparisons against diffusion language models at matched sizes, timed on one Nvidia H100.
• Against a normal word-by-word model, it still writes worse. In the paper's own table, the word-by-word model wrote clearly more natural text.
• These models are tiny. Most are around 100 million parameters. The AI you chat with is likely hundreds of times bigger. Nobody knows yet if this holds up at that size, and the authors say so themselves.
• Fewer passes isn't free. Each pass does more work, and it always runs through every layer, even for a two-word answer.
• It's a preprint. And the repo targets Nvidia GPUs. We changed two small things to run it on a Mac.

So, is it the end of LLMs?

No. NCM is itself a transformer. It's still a large language model, just one that writes differently.

Should Nvidia be worried this year? Also no. The paper makes no claim about chips, memory or memory prices, and the authors ran their own speed tests on Nvidia hardware. The memory angle is our reading, not theirs.

Here's why the paper matters anyway. Today, the expensive part of AI is the walk to memory, a thousand times per answer. If ideas like this one scale, the bottleneck could shift from memory to raw computing power. That changes which chips matter, and it's how good AI ends up running on laptops and phones instead of only in giant data centers. We watched a small version of that happen on our own laptop.

So the open question is a trade: would you take an AI that's twenty times faster and cheaper, but writes a little worse?

Sources: Next-Concept Modeling: Fast, Parallel Coarse-to-Fine Text Generation (Stanford + Together AI, arXiv 2610.14162), the NCM code and models, and the trained checkpoints.

Run it yourself

We made a free guide: NCM in plain English, the honest scorecard, and the exact commands we used to run it on a Mac. Comment CONCEPT on the video, or grab it below.

How we tested: laptop results are from our own run on October 21, 2026 with the released checkpoints. The 1% vs 86% Sudoku comparison is between two 25M-parameter models from the paper's Table 3. Independent post, not affiliated with Stanford, Hazy Research, Together AI or Nvidia.