NVIDIA Dory 1.0: 4B Looped Model Hits 61.8 SWE-bench

Yesterday, NVIDIA Dory 1.0 landed on Hugging Face — and it breaks the rule that smarter AI costs more money. This 4-billion-parameter open-weight model has a built-in “thinking dial”: you choose how many times its core reasoning block loops at inference time. At four loops it scores 61.8 on SWE-bench Verified, beating far larger open models at fixing real software bugs. At one loop, the same checkpoint runs cheap and fast.

That dial is the money story. A tiny model that thinks harder only when the task deserves it means near-free agentic coding: cheap runs for drafting, full-throttle reasoning for the bugs clients actually pay to fix. Released October 16, 2026 under the commercial-friendly OpenMDW-1.1 license, Dory is built for exactly this work. Here is what it is, what the numbers say, and how to turn it into income.

A 4B model with a thinking dial

Looped (recurrent-depth) sounds exotic, but the idea is simple: instead of stacking hundreds of unique layers, Dory reuses one shared block of 20 “recurrent” layers, running your input through it again and again. Each pass is a loop — pick 1 to 4 at inference time, with no retraining and no model swap. More loops mean more compute per token and deeper reasoning.

NVIDIA calls this elastic inference compute: one checkpoint serves different compute budgets, and looping needs fewer generated tokens per task since the thinking happens in latent space. Specs: 4B parameters, 256K-token context, 6T training tokens, shipped in BF16, MXFP8, NVFP4, and Q5_K_M GGUF formats for local runs.

The exact numbers, straight from NVIDIA’s model card

NVIDIA published a full benchmark table measured under its own consistent harness. Here it is, unedited — Dory1.0-4B at 1, 2, and 4 loops against four rival open models:

*Reported scores. Source: the official Dory1.0-4B-GGUF model card on Hugging Face (NeMo Gym / NeMo Evaluator SDK harness). Dory figures are for the BF16 variant.

“By changing how many times the shared block of layers is applied, you can trade inference compute for accuracy to suit each task, with no retraining and no model swap.”

— NVIDIA, Dory1.0-4B-GGUF model card

Where Dory leads — and where it doesn’t

SWE-bench Verified tests whether AI can fix real GitHub issues — the closest public proxy to freelance debugging. At 4 loops, Dory’s 61.8 beats Qwen3.5-9B (61.0) and Gemma 4 26B A4B (57.40), both far larger models. It also tops IFBench (79) and the τ³-bench banking tasks (14.69), but trails on pure reasoning and general knowledge. The dial is everything: at 1 loop, SWE-bench falls to 50.3, below Qwen3.5-4B’s 54.7.

How looped depth works

The stack is split in three: the 8-layer input block reads your prompt, the shared 20-layer recurrent block loops over it N times (input reinjected every loop), and the 8-layer output block writes the answer. NVIDIA recommends 2 loops as the default; last-loop KV caching keeps memory flat at any loop count.

How to profit from Dory 1.0

A specialist coding model you can run for pennies. Five concrete moves:

1. Sell AI bug-fix sprints. Offer fixed-price “repo rescue”: Dory at 4 loops against failing tests and open issues; you review the patches and ship. You bill for the outcome.
2. Dial compute to protect margin. 1 loop for cheap drafting, 2 for everyday tickets, 4 for the gnarly bugs that justify premium pricing. Cost per task stays under your control.
3. Productize a micro-tool. Wrap the model in a narrow debugging assistant — one framework, one CMS — and sell it as a subscription. Tiny open models make solo-SaaS economics work.
4. Pitch “reasoning on demand” to agencies. Fast cheap answers for routine work, deep reasoning for hard problems, from one deployment. Bigger models can’t match that price.
5. Learn the looped workflow early. Prompting and agent harnesses behave differently across loop counts. Expertise here is a differentiator while the field is fresh.

Getting started is cheap: grab the ~3.67 GB Q5_K_M GGUF from the official model card, load it in a Dory-enabled llama.cpp build, and set dory.num_loops. The release is independently confirmed by The Deploy Log entry for the Dory1.0-4B-MXFP8 release (published Friday, October 16, 2026).

Frequently asked questions

What is NVIDIA Dory 1.0?

A 4B open-weight model from NVIDIA’s Nemotron Labs, released October 16, 2026. You choose at inference time how many times its shared reasoning block runs, trading compute for accuracy per task.

What does “looped (recurrent-depth)” mean?

The model reuses one block of 20 layers repeatedly. You set the loop count (1–4); each extra pass lets it “think longer” per token, which pays off most on hard coding tasks.

What is SWE-bench Verified?

A benchmark testing whether AI can fix real bugs: the model gets actual GitHub issues from open-source projects and must produce patches that pass their tests. Dory 1.0 scores 61.8 at 4 loops.

Is Dory 1.0 free for commercial use?

It ships under the OpenMDW License Agreement v1.1; NVIDIA says it is “ready for commercial or non-commercial use.” Read the license yourself before building a business on it.

How many loops should I use?

NVIDIA recommends 2 loops as the default — most of the gain comes from the second loop. Use 1 to minimize cost, 4 for maximum accuracy on agentic coding tasks.

Where can I download it?

From the official Dory1.0-4B-GGUF model card on Hugging Face (BF16, MXFP8, NVFP4, Q5_K_M GGUF) — the GGUF export is the one for local llama.cpp runs.