On October 16, NVIDIA's Nemotron Labs quietly published a new entry: Dory 1.0-4B. There was no flagship launch event and no flood of press releases, but the architecture takes a road few have traveled: a looped language model, where parameters stay fixed at 4B while "thinking depth" becomes a dial you can turn at inference time.

A looped architecture: thinking budget as a knob

According to the model card, Dory is a looped (latent-recurrent) normalized-GPT whose attention layers interleave sliding-window attention (SWA) with full attention. The core mechanism is repeatedly applying a shared block of layers — in NVIDIA's words, the model can spend more compute per token to scale intelligence. At inference you choose 1, 2, or 4 loops: more loops mean more compute per token and higher accuracy, at the cost of latency.

The card recommends two loops as the default and notes that most of the accuracy gain comes from the second loop, with diminishing returns beyond. For deployers, that's a 4B model shipping with three "thinking budget" presets — speed and accuracy stop being an either-or choice over a single set of weights.

Supporting specs: up to 256K tokens of context, released in BF16, English-only, OpenMDW-1.1 license permitting commercial and non-commercial use. Training draws on NVIDIA's Nemotron datasets; the post-training pipeline includes filtering pathological repetition in reasoning traces and targeted removal of trajectories where teacher models occasionally produced nationalist narratives — a detail you rarely see spelled out in a model card.

Self-reported benchmarks: wins instruction following, loses knowledge

The official table pits Dory at 1/2/4 loops against Qwen3.5-4B, Qwen3.5-9B, Gemma 4 26B-A4B, and Qwen3.6-35B-A3B. Caveat first: all numbers are NVIDIA's own, with no third-party replication yet.

The wins cluster in instruction following and agentic tasks: IFBench 79 at four loops versus 59 for Qwen3.5-9B (53.83 for the 4B); τ³-bench Banking at 14.69 — the highest in the row, double the 9B's 7.22; long-context AA-LCR at 71/73 also beats every comparator. On code, SciCode 35.11 clears the 9B's 28.21, and SWE-bench Verified 61.8 essentially matches 61.

The other side is equally blunt: GPQA Diamond 72.41 versus 80.93 for the 9B, HLE 10.89 versus 15.43, AA-Omniscience at 10.08 versus 18.05, and Terminal-Bench 2.1 at 22.2 behind the 9B's 24. The pattern is clear — looping adds inference compute; it cannot add the knowledge stored in parameters. A 4B parameter count decides how much the model knows; loop count only decides how deeply it thinks. That draws a crisp boundary around looped architectures.

Ecosystem niche: laptop-runnable, but the toolchain isn't merged

The GGUF quantized export (Q5_K_M) is about 3.4 GB, the model card ships a llama.cpp build guide for Apple Silicon, and aggregator The Open Weights files it under "runs on a laptop." On DGX Spark, NVIDIA reports MXFP8 quantization running 1.69-1.84x faster than BF16 and NVFP4 at 2.17-2.44x.

Early adoption has a catch: vLLM support is still under review (vllm-project#60149), and llama.cpp requires building from PR #30306 — neither has landed in an official release. Everyone boarding now is a toolchain player willing to compile.

So what

Dory's real story isn't any single benchmark column; it's NVIDIA casting a vote for "small parameters plus tunable test-time compute" with a 4B model. If looped architectures validate, model selection on edge devices may shift from "how big a model" to "how many loops." For most developers, waiting for the vLLM merge is reasonable; for researchers, the boundary between knowledge density and loop depth is the thing to watch.