NVIDIA Dory1.0-4B Benchmarks: Looping vs Qwen3.5 and Gemma 4
NVIDIA's Dory1.0-4B scales accuracy by looping, not parameters. Here's how its 1, 2, and 4-loop scores compare to bigger rivals.
What is NVIDIA’s Dory1.0-4B and how does it compare to Qwen3.5 and Gemma 4?
Dory1.0-4B is a 4-billion-parameter open-weight model from NVIDIA’s Nemotron Labs that uses a looped (latent-recurrent) architecture instead of adding more parameters to get smarter. Rather than shipping separate small, medium, and large checkpoints, NVIDIA released one model that can run its shared recurrent block 1, 2, or 4 times at inference, trading compute for accuracy on the fly. On NVIDIA’s own benchmark tables, the 4-loop version of Dory1.0-4B beats Qwen3.5-4B and Qwen3.5-9B on several coding and agentic tasks, despite having fewer or comparable active parameters, though it still trails Qwen3.6-35B-A3B and Gemma 4 26B A4B on broad reasoning and knowledge tests.
TL;DR
- Dory1.0-4B uses a looped architecture that reapplies a shared 20-layer recurrent block between fixed input and output blocks (8 layers each), letting one checkpoint serve multiple compute budgets.
- Accuracy climbs with loop count but plateaus fast. NVIDIA’s own guidance says most of the gain comes from going 1 loop to 2 loops, with smaller returns from 2 to 4.
- On SWE-bench Verified, Dory1.0-4B at 4 loops scores 61.8, ahead of Qwen3.5-4B (54.7) and roughly matching Qwen3.5-9B (61), despite being a smaller model by active footprint.
- On harder knowledge and reasoning benchmarks like GPQA Diamond and AA-Omniscience, Dory1.0-4B falls behind both Qwen3.5-9B and the larger Gemma 4 26B A4B and Qwen3.6-35B-A3B models.
- Looping cuts generated tokens, not just raw accuracy. NVIDIA reports that higher loop counts solve the same tasks with fewer output tokens because extra compute goes into latent-space “thinking” rather than longer text generation.
- Memory doesn’t have to scale with loop count. A “last-loop” KV caching mode keeps memory overhead flat regardless of how many loops run, unlike standard looped models where each loop adds its own cache.
- The model is available in BF16, MXFP8, NVFP4, and Q5_K_M formats, with native NVFP4 pretraining before BF16 continuation, and runs via vLLM or llama.cpp with loop count set as a launch parameter.
Seven tools to build an app. Or just Remy.
Editor, preview, AI agents, deploy — all in one tab. Nothing to install.
How does the looped architecture actually work?
Dory1.0-4B splits its layer stack into three groups: an Input block (I), a Recurrent block (R), and an Output block (O). In this release, the Input and Output blocks each have 8 layers, and the Recurrent block has 20 layers. The key trick is that the Recurrent block isn’t run once. It’s applied multiple times in sequence, with the original input re-injected into the model at every pass through the loop. Each additional loop effectively lets the model reconsider and refine its internal representation before producing an answer, all without adding new parameters or swapping checkpoints.
This is different from simply making a model bigger or chaining separate models together. The weights in the recurrent block are shared across every loop, so a 4-loop run and a 1-loop run use the exact same parameter set, just applied a different number of times. NVIDIA describes this as “elastic inference compute”: one set of weights, multiple accuracy/latency tradeoffs, selected by a runtime flag rather than a retrain.
The architecture also uses interleaved sliding-window attention (SWA) and full-attention layers, built on a normalized-GPT (nGPT) backbone. Dory1.0-4B was pretrained natively in NVFP4, NVIDIA’s 4-bit floating-point format, before continuing training in BF16, which is part of why the model ships in multiple quantization formats (BF16, MXFP8, NVFP4, Q5_K_M) out of the gate.
What do the benchmark numbers actually show?
NVIDIA’s model card publishes a benchmark table comparing Dory1.0-4B at 1, 2, and 4 loops against Qwen3.5-4B, Qwen3.5-9B, Gemma 4 26B A4B, and Qwen3.6-35B-A3B, across coding/agentic tasks, reasoning, instruction following, long context, and general knowledge. All scores were measured under a consistent harness (NeMo Gym / NeMo Evaluator SDK), except where marked as reported scores from other sources.
A few patterns stand out:
Coding and agentic tasks are where looping pays off most. On SWE-bench Verified, Dory1.0-4B goes from 50.3 (1 loop) to 59.5 (2 loops) to 61.8 (4 loops), surpassing Qwen3.5-4B’s 54.7 and landing close to Qwen3.5-9B’s 61. On Terminal-Bench 2.1, the model climbs from 12.5 to 18.1 to 22.2 across loop counts, though it still lags behind Qwen3.5-9B (24) and the larger models (35 and 43). On the GDPval-AA-V2 Elo ranking, Dory1.0-4B jumps from 815 at 1 loop to 967 at 4 loops, clearing both Qwen3.5 variants (424 and 546) and Gemma 4 26B A4B (751.6), landing just under Qwen3.6-35B-A3B’s 987.
Reasoning and general knowledge are weaker spots. On GPQA Diamond, Dory1.0-4B tops out around 72 across loop counts, behind Qwen3.5-4B (77.71), Qwen3.5-9B (80.93), and the larger models (80.43 and 85.35). AA-Omniscience, a general knowledge accuracy test, is the starkest gap: Dory1.0-4B sits around 10 regardless of loop count, while every competitor scores between 15 and 21. This suggests looping adds reasoning and agentic capability, but it doesn’t substitute for the broader world knowledge that comes with more total training data or parameters.
Everyone else built a construction worker.
We built the contractor.
One file at a time.
UI, API, database, deploy.
Instruction following is a strong point. On IFBench, Dory1.0-4B reaches 79 at 4 loops, ahead of Qwen3.5-4B (53.83), Qwen3.5-9B (59), and Qwen3.6-35B-A3B (57.44), and roughly matching Gemma 4 26B A4B (77.89).
Long context holds up well too. On AA-LCR, Dory1.0-4B reaches 73 at 4 loops, ahead of all four comparison models (64.7, 68.4, 64.6, 68.5).
Why does loop count matter more than raw parameter count here?
The benchmark table makes the point implicitly: Dory1.0-4B’s 4-loop score frequently beats its own 1-loop score by double digits on agentic and coding tasks, which is a bigger swing than the gap between some of the competing model sizes. NVIDIA’s guidance in the model card recommends 2 loops as the default starting point, since “most of the accuracy gain from looping comes from the second loop,” with 4 loops recommended specifically for agentic workloads like Terminal-Bench and SWE-bench where the extra compute clearly helps.
This matters for anyone deploying small models in production. A typical 4B model is locked into one capability/cost tradeoff at release time. Dory1.0-4B lets you dial that tradeoff per request: run 1 loop for cheap, low-latency tasks, and 4 loops when a harder coding or agentic task justifies the extra compute, all from the same deployed checkpoint.
There’s also a token-efficiency angle. NVIDIA reports that as loop count increases, the model needs fewer generated tokens to solve the same tasks, because the extra computation happens in latent space during the loop rather than being spent on longer chain-of-thought text. That’s relevant for cost, since inference pricing is typically tied to tokens generated, not just wall-clock compute.
Is the memory overhead from looping a problem?
It can be, if handled naively. Standard looped models share parameters across loops but still need a separate KV cache per loop, so memory grows linearly with loop count. NVIDIA’s answer is “last-loop KV caching,” which keeps a single cache per recurrent attention layer, with each loop overwriting the previous one’s entries rather than appending to it. The result: memory footprint stays at the 1-loop size no matter how many loops run. NVIDIA states that in its experiments, accuracy with last-loop caching stays close to the standard per-loop mode, with output lengths barely changing.
This is configured via a recurrent_kv_cache_mode flag at launch (per_loop or last_loop) in both the vLLM and llama.cpp quick-start instructions on the model card, alongside the n_recurrent_loops parameter that sets loop count.
Is Dory1.0-4B worth using over Qwen3.5 or Gemma 4?
It depends on the workload. For coding, agentic, and instruction-following tasks, Dory1.0-4B at higher loop counts is competitive with or better than Qwen3.5-9B, which is more than double its parameter count, and sometimes approaches the much larger Qwen3.6-35B-A3B on specific benchmarks like GDPval-AA-V2. For teams that need to run small, cheap models but occasionally need extra accuracy on harder agentic tasks, the elastic compute model is a real advantage over having to swap checkpoints.
- ✕a coding agent
- ✕no-code
- ✕vibe coding
- ✕a faster Cursor
The one that tells the coding agents what to build.
For broad reasoning (GPQA Diamond) and especially general knowledge (AA-Omniscience), it’s clearly behind every comparison model in the table, including models of similar or slightly larger size. Anyone choosing between these models for knowledge-heavy or open-domain Q&A use cases should weigh that gap carefully; looping doesn’t appear to close it.
Frequently Asked Questions
What does “looped” or “latent-recurrent” mean in Dory1.0-4B?
It means the model reapplies the same shared block of layers (the Recurrent block) multiple times per forward pass, re-injecting the original input at each pass. This lets the model spend more compute per token without adding parameters, unlike simply scaling up model size.
How many loops should I use when running Dory1.0-4B?
NVIDIA recommends 2 loops as a default balance of accuracy and compute. Use 1 loop to minimize cost per token, and consider 4 loops for agentic tasks like SWE-bench or Terminal-Bench where the extra accuracy is worth the compute.
Does more looping always mean better accuracy?
No. Gains tend to plateau after the second loop in NVIDIA’s own benchmarks, and on some tasks (like GPQA Diamond) accuracy at 4 loops is roughly flat or even slightly lower than at 2 loops.
How does Dory1.0-4B compare to Qwen3.5-9B on coding benchmarks?
On SWE-bench Verified, Dory1.0-4B at 4 loops (61.8) is roughly on par with Qwen3.5-9B (61), despite Dory having fewer total parameters. On Terminal-Bench 2.1, however, Qwen3.5-9B (24) still outperforms Dory1.0-4B at 4 loops (22.2).
What formats and tools support Dory1.0-4B?
The model ships in BF16, MXFP8, NVFP4, and Q5_K_M formats. It can be served through vLLM (with Dory support pending a merged pull request) or llama.cpp (with a similar in-review pull request), with loop count and KV cache mode set as launch-time configuration options.
