Hand someone a dense paragraph and they’ll often read it twice. Same eyes, same brain, same words on the page. The second pass still lands differently, because the first one left something behind. The NVIDIA Dory looped model tries a machine version of that habit. It runs the same block of layers again and again, and you get to choose how many times.
That raises a question the spec sheets skip. What does it mean for a machine to “think longer”? Today’s reasoning models mostly do it by writing. They produce long chains of visible text before they answer. Dory does it silently, inside its own layers, without adding a single parameter.
Those are two very different ideas of effort. The difference matters for anyone who wants to check an AI’s work.
One warning first. Every Dory number in this piece traces back to NVIDIA’s own model card, via third-party write-ups. NVIDIA hasn’t published a paper or a launch post, and nobody has reproduced the results independently. Treat the benchmarks as claims, not findings.
What does it mean for a machine to “think longer”?
For a person, thinking longer is vague but familiar. You slow down, reread, turn the problem over. For a language model, the phrase has had a much narrower meaning.
The standard approach is chain-of-thought. The model writes out intermediate steps as text, then answers. More thinking means more tokens, and more tokens mean more time and cost. The upside is a scratchpad you can read, at least in principle.
A second approach has been growing in research labs since early 2025. In a February 2025 paper on latent reasoning with recurrent depth, Geiping and colleagues described a model that repeatedly applies a recurrent block, “unrolling to arbitrary depth at test-time.” Their model reasons in latent space, meaning its internal numerical representations, instead of generating extra words.
It also needed no special chain-of-thought training data. The authors argue it can capture kinds of reasoning that are hard to put into words. Their proof-of-concept had 3.5 billion parameters and trained on 800 billion tokens. With more test-time compute, it scored like a far bigger model. The authors put the equivalent at up to 50 billion parameters.
That’s the family Dory belongs to. Reasoning without words sounds very human. Whether the process behind it is human-like is a separate question, and we’ll come back to it.
What is a looped language model?
Most models you’ve used work like a stack. Text goes in at the bottom, passes through each layer exactly once, and comes out the top as a prediction. If you want more depth, you add layers, and every new layer adds parameters. Our explainer on how large language models work covers that standard stack in detail.
A looped language model breaks the one-pass rule. It keeps a fixed set of layers and sends the signal through some of them more than once. The usual shape has three parts:
- A prelude (Dory calls it the input block) turns tokens into internal representations.
- A recurrent core runs repeatedly, refining those representations on each pass.
- A coda (the output block) turns the final state into a prediction.
The trade is simple. Compute grows with every loop. The parameter count doesn’t, because each loop reuses the same weights.
If that sounds familiar, it should. Classic recurrent neural networks also reuse their weights, though across a sequence of inputs rather than across depth.
What is the NVIDIA Dory looped model?
The NVIDIA Dory looped model goes by the full name Nemotron Labs Dory 1.0 4B. It’s an open-weight model with 4 billion parameters, and its weights appeared on Hugging Face on October 16–17, 2026. According to orcarouter’s account of the quiet release, NVIDIA hasn’t formally announced it at all.
Here’s the layout, as MindStudio’s breakdown relays it from the model card:
- 8 layers in the input block
- 20 layers in a recurrent block that repeats
- 8 layers in the output block
The model feeds the original input back in on every pass. You pick the loop count at serving time, and you don’t have to retrain anything. The model card’s guidance, per orcarouter, goes like this: one loop for the lowest latency, two as the recommended default, and four for agentic tasks where accuracy matters more than speed. Those are the jobs where a model acts on its own across many steps, so a slow but careful answer can be worth the wait.
Do the arithmetic and the cost comes into view. One loop means 36 layer executions. Two loops mean 56. Four loops mean 96, about 2.7 times the single-loop work, all from the same 4 billion parameters.
A few other details from the card:
- A context window of up to 256K tokens, with 262,144 positions validated in vLLM
- The OpenMDW 1.1 license
- English only
Runtime support is still catching up. The vLLM and llama.cpp integrations sat in unmerged pull requests when orcarouter wrote its piece.
Looping versus chain-of-thought: two ways to spend extra compute
Here’s the cleanest way I can put the difference. Chain-of-thought spends compute outward, as words. Looping spends it inward, as depth. The NVIDIA Dory looped model sits firmly on the inward side.
Each choice has a cost. Chain-of-thought makes answers longer and slower, but it leaves a trail. Looping keeps the output short. NVIDIA even claims that higher loop counts can produce fewer output tokens, since more of the work happens in latent space.
The price is that the trail disappears. There’s no paragraph of reasoning to read. There are only internal states, and researchers would need interpretability tools to make sense of them.
So which approach works better? It depends on the problem. A formal comparison by Xu and Sato, titled “To CoT or To Loop?”, found that looped transformers efficiently simulate parallel computation on deterministic tasks. Chain-of-thought with stochastic decoding suits approximate inference on a class of self-reducible problems. In plain terms, neither approach wins everywhere.
The Ouro team goes further. That group (Zhu and 32 co-authors, Yoshua Bengio among them) pretrained looped models on 7.7 trillion tokens. They report that looped reasoning traces line up more closely with final outputs than explicit chain-of-thought does. That’s the authors’ claim, not a settled result. If it holds up, it’s an odd twist: the readable scratchpad might be the less faithful record.
What the NVIDIA Dory looped model’s results do and don’t show
Now the numbers, with the caveats attached. NVIDIA’s table, as both MindStudio and orcarouter relay it, shows this on the SWE-bench Verified coding benchmark:
- 1 loop: 50.3
- 2 loops: 59.5
- 4 loops: 61.8
Terminal-Bench 2.1 climbs in a similar pattern, from 12.5 to 18.1 to 22.2.
Look at where the gain sits. Going from one loop to two adds about nine points on SWE-bench. Doubling again, to four, adds about two more. Most of the benefit arrives early.
Other benchmarks tell a messier story:
- GPQA Diamond, a set of hard science questions, peaks at two loops. It scores 69.19, then 72.41, then a slightly lower 72.16 at four.
- AA-Omniscience, a factual-recall test, sits near 10 at every loop count. More loops, no extra facts.
At four loops, the reported SWE-bench score edges past Qwen3.5-4B (54.7) and Qwen3.5-9B (61). The NVIDIA Dory looped model still trails larger models on GPQA Diamond, AA-Omniscience and HLE.
Then come the caveats, which orcarouter lays out bluntly:
- The “AA” figures are NVIDIA’s internal estimates, not official Artificial Analysis scores.
- NVIDIA ran several benchmarks only once.
- At least one competitor score came from reported figures, not from NVIDIA’s own runs.
- No independent group had reproduced any of it as of October 17.
None of this means the numbers are wrong. It means they’re a vendor’s first draft of the story.
There’s a hardware wrinkle too. NVIDIA says that caching key-value memory for every loop makes memory grow with the loop count. Caching only the last loop keeps memory near single-loop size, and NVIDIA describes the accuracy as “close.” That word deserves an outside test.
Is looping like human deliberation?
The rereading analogy holds in one narrow way. A looped model reprocesses the same input with the same machinery several times, and each pass builds on the last. That’s roughly what you do with a knotty clause in a rental contract.
It breaks in at least two places. What follows is my reading of the facts above, not a sourced finding.
First, you choose when to reread. You notice you’re confused, and you slow down for that one sentence. Dory doesn’t notice anything. Its loop count is a setting that whoever runs the model picks in advance. Ouro differs here. Its authors describe an entropy-regularized method for learning how much depth to spend, which is a step closer to effort that tracks difficulty.
Second, rereading can’t hand you a fact you never learned. The flat AA-Omniscience scores suggest the same holds for Dory. Looping seems to help a model work with what it knows, not know more. The Ouro authors land somewhere similar. They credit their gains to better knowledge manipulation, not greater knowledge capacity.
So “thinking longer” means something real here, but something specific. It’s more passes over the same internal material. It isn’t doubt, and it isn’t going off to look something up.
What to watch next for the NVIDIA Dory looped model
Dory is small and barely a week old. The open questions outnumber the answers.
- Independent evaluation. Until someone outside NVIDIA reruns SWE-bench and GPQA Diamond, the loop curve stays a claim.
- Merged runtime support. While the vLLM and llama.cpp work sits unmerged, fewer people can test the model easily.
- Cost per completed task. Four loops cost about 2.7 times the layer work of one. If shorter outputs offset that, looping could pay for itself on agent workloads. If they don’t, the extra points get expensive.
- Scale. Ouro’s authors report 1.4B and 2.6B looped models matching standard models of up to 12B. Nobody knows yet whether the trick keeps paying off far beyond 4 billion parameters.
Why the NVIDIA Dory looped model’s dial is the real story
The most interesting part of the NVIDIA Dory looped model isn’t the SWE-bench score. It’s the dial. The person running the model decides how hard it thinks, and that thinking leaves no transcript behind.
I find that trade more important than any single benchmark. Visible chain-of-thought gave us an imperfect window into machine reasoning, and it only arrived recently. Looped models offer cheaper effort in exchange for closing some of that window again.
Before you turn the dial to four, it’s worth asking yourself one thing. What would you need to see to trust an answer whose reasoning you can’t read?
