NVIDIA has quietly released Nemotron Labs Dory 1.0 4B, an open-weight language model designed for reasoning, coding and agentic tasks. Published on Hugging Face on October 16, 2026, the model has 4 billion parameters and supports a context window of up to 256,000 tokens. Its defining feature is a looped neural-network architecture that allows developers to adjust how much computation the model performs during inference, using the same underlying checkpoint.
Unlike conventional language models that use a fixed stack of layers for each forward pass, Dory repeatedly applies a shared block of layers. NVIDIA says this approach lets developers trade additional computation for better performance on demanding tasks without downloading a different model. The release includes multiple model formats and benchmark results across different loop settings, although the reported scores have not been independently verified. The model is available under NVIDIA’s OpenMDW 1.1 license, whose terms developers should review before deployment.
Key Takeaways
- Model: NVIDIA Nemotron Labs Dory 1.0 4B.
- Parameters: 4 billion.
- Context window: Up to 256,000 tokens.
- Architecture: Looped, latent-recurrent normalized GPT with hybrid attention.
- Adjustable computation: Developers can change the number of recurrent loops to balance computational cost and task performance.
- Training: NVIDIA reports 6 trillion pre-training tokens, followed by a 300-billion-token context-extension phase and post-training.
- Formats: BF16, MXFP8, NVFP4 and GGUF.
- Availability: Published on Hugging Face under the OpenMDW 1.1 license.
What Is NVIDIA Nemotron Labs Dory 1.0 4B?
Dory 1.0 4B is part of NVIDIA’s Nemotron Labs model family, which explores language-model architectures and methods for building more capable AI systems.
The model is designed for text-based tasks, including mathematics, scientific reasoning, programming, instruction following and multi-step tool use. It is not a multimodal model: its published specification lists text as both its input and output modality, with English as its supported natural language.
The 4B designation refers to approximately 4 billion parameters, the learned values used by the neural network. Parameter count can help indicate a model’s size and deployment requirements, but it does not determine performance on its own. Architecture, training data, post-training and inference settings also influence results.
Dory’s approach is particularly interesting because it attempts to increase the computation available to a model without requiring a proportionate increase in the number of unique parameters. This makes it relevant to developers exploring smaller models for reasoning and agentic workloads.
The model is available through NVIDIA’s repositories on Hugging Face, where developers can inspect the model card, download compatible checkpoints and review the recommended inference configuration.
How the Looped Architecture Works
Most conventional transformer language models process input through a fixed sequence of neural-network layers. Dory uses a different structure: it divides its network into input, recurrent and output blocks, with the recurrent block applied repeatedly.
NVIDIA describes Dory’s architecture as containing an eight-layer input block, a shared 20-layer recurrent block and an eight-layer output block. The recurrent block can be applied multiple times during inference.
A simplified representation looks like this:
Input layers → Recurrent block → Recurrent block again → Output layers
The number of repetitions is adjustable. More loops give the model additional computation to work through a problem, while fewer loops can reduce computational requirements.
This is not the same as increasing the model’s parameter count. The same shared block is reused, allowing the model to spend more computation on a task without storing an entirely separate set of weights for every repetition.
The architecture also combines sliding-window attention with full-attention layers. Sliding-window attention focuses on a limited portion of the sequence, while full attention allows the model to relate information across a much larger span. Combining the two approaches helps balance local processing with access to longer-range context.
Why adjustable computation matters
Developers building AI agents often face a trade-off between speed, cost and accuracy. A simple instruction may not need extensive reasoning, while a multi-step coding task or complex mathematical problem may benefit from additional computation.
Dory lets developers adjust the recurrent loop count without switching checkpoints or retraining the model. NVIDIA recommends starting with two loops as a general balance between computation and performance, while one loop may suit latency-sensitive tasks and four loops may be useful when additional task accuracy matters.
The trade-off is workload-dependent. More loops do not guarantee better results on every benchmark or prompt, and they can increase computational demand. Developers should evaluate latency, memory use and accuracy against their own applications before selecting a setting.
A 256K Context Window for Long Documents and Agent Workflows
One of Dory’s most prominent specifications is its context window of up to 256,000 tokens.
A context window determines how much text the model can process within a single interaction, including the supplied prompt and relevant conversation or document content. It is measured in tokens rather than words, so the number of pages it can accommodate varies with the content and formatting.
A large context window can help with tasks such as:
- Reviewing lengthy technical documentation.
- Analysing large codebases or multiple source files.
- Following extended instructions across multi-step workflows.
- Extracting information from long reports.
- Maintaining relevant context while using tools to complete a task.
For example, a coding agent may need to examine a project’s documentation, several source files and a sequence of test results before suggesting a fix. A large context window can reduce the need to divide that information into many separate requests.
However, 256K context does not mean the model will understand every detail perfectly. Long-context performance depends on how well the model retrieves relevant information, reasons across distant sections and handles conflicting instructions.
It also does not make long prompts free to process. Hardware capacity, attention mechanisms, inference settings and concurrent requests affect memory use and operating costs.
NVIDIA’s Training Approach and Model Formats
NVIDIA’s model card says Dory was pre-trained on 6 trillion tokens. The company reports that the first approximately 4.5 trillion tokens were processed using its NVFP4 numerical format, with the remainder of pre-training using BF16. A further 300-billion-token phase extended the context length, followed by supervised fine-tuning and reinforcement learning.
The post-training process was designed to improve performance across reasoning, code, instruction following, multi-step tool use and structured output. NVIDIA identifies Group Relative Policy Optimization, or GRPO, as part of its reinforcement-learning approach.
The model is published in several formats to accommodate different deployment environments.
| Format | General purpose |
|---|---|
| BF16 | Higher-precision model weights |
| MXFP8 | Eight-bit floating-point representation |
| NVFP4 | NVIDIA’s four-bit floating-point format |
| GGUF | A model format commonly used with local inference tools |
These formats differ in memory requirements, numerical precision and software compatibility. Lower-precision formats can reduce storage and inference-memory requirements, but quantisation may affect output quality depending on the model and workload.
Availability in GGUF is particularly relevant to developers exploring local inference, although the ability to run Dory depends on the compatible runtime, hardware and configuration. NVIDIA’s published instructions indicate that support requires a specific vLLM development build or compatible llama.cpp implementation rather than assuming that every standard installation will work immediately.
What Do Dory’s Benchmarks Show?
NVIDIA publishes results for different loop settings on several reasoning and coding evaluations. Its figures suggest that additional loops can improve performance on some tasks, though the effect varies by benchmark.
For example, NVIDIA reports the following scores for Dory 1.0 4B:
| Benchmark | 1 loop | 2 loops | 4 loops |
|---|---|---|---|
| SWE-bench Verified | 50.3 | 59.5 | 61.8 |
| GPQA Diamond | 69.19 | 72.41 | 72.16 |
| SciCode | 27.3 | 34.94 | 35.11 |
| Terminal-Bench 2.1 | 12.5 | 18.1 | 22.2 |
Source: NVIDIA’s published model card. These are vendor-reported results, not independently reproduced findings. Scores are shown in the benchmark’s reported units.
The results illustrate why adjustable computation is a central part of the design. SWE-bench Verified scores rise from 50.3 with one loop to 61.8 with four loops, while Terminal-Bench 2.1 also shows a substantial increase. GPQA Diamond, however, peaks at two loops in the published figures, demonstrating that more computation does not improve every result.
Benchmark comparisons also require care. Scores depend on evaluation methods, prompts, tools, hardware, model versions and the number of attempts. A model’s performance on a particular test does not guarantee that it will perform similarly in a real software project or business workflow.
For developers, the most useful test is to compare Dory against alternatives on the actual tasks they need to complete, measuring accuracy alongside latency, memory consumption and cost.
How Dory Could Be Used in Agentic AI
Agentic AI systems do more than generate a single response. They can plan a task, call tools, inspect results and take additional steps based on what they discover.
Dory’s combination of reasoning-oriented post-training, tool-use capabilities and adjustable computation makes it a potential option for these workflows.
A software-development agent, for example, might inspect a code repository, propose a change, run tests and revise its solution after receiving an error. A research assistant might gather information from documents, compare evidence and produce a structured report.
Smaller models can be attractive for such applications because they may be easier to deploy than very large systems. But the overall economics depend on how much computation the model needs, how reliably it completes tasks and how much surrounding software is required.
A 4B model is not automatically suitable for every agent. Complex workflows may require stronger models, specialised tools or human review. Dory’s performance will also depend on the quality of the inference implementation and how developers configure its recurrent loops.
Availability, Licensing and Deployment Considerations
Dory 1.0 4B is available through NVIDIA’s Nemotron Labs collection on Hugging Face, including separate repositories for its supported formats.
The model uses the OpenMDW 1.1 license agreement. Developers should read the actual license before using it commercially or incorporating it into a product, rather than assuming that the term “open-weight” means unrestricted use or that the model is licensed under a standard open-source software license.
Deployment also requires attention to hardware and runtime compatibility. Although the model’s parameter count is relatively small compared with larger frontier models, its 256K context window and recurrent computation settings can still create meaningful memory and processing requirements.
Developers should begin with NVIDIA’s recommended two-loop configuration, test a smaller context length if resources are constrained, and compare different loop settings on representative tasks. This approach can help establish whether the model’s flexibility delivers a useful performance improvement for the intended application.
The Bigger Picture
Dory 1.0 4B highlights an alternative approach to scaling language-model performance. Instead of relying only on larger parameter counts, NVIDIA is exploring a model that can reuse a shared block of layers and allocate different amounts of computation at inference time. Combined with a 256K context window, the architecture targets developers who want a compact model for reasoning, coding and agentic workflows.
The release also reinforces the importance of practical deployment details. Benchmark performance, context length and parameter count are only part of the decision; hardware requirements, runtime support, licensing and real-world reliability matter just as much. Dory’s longer-term significance will depend on independent evaluation and whether developers find its adjustable computation useful outside the benchmark environment.
Looking Ahead
Developers can now examine Dory’s model card, download the available checkpoints and test its loop settings on their own workloads. NVIDIA’s published results provide an initial view of how performance changes with additional computation, but independent testing will be important for understanding how the model compares with other compact reasoning systems.
More broadly, Dory represents ongoing experimentation with architectures that aim to improve capability without simply increasing model size. If adjustable computation proves practical across real applications, similar approaches could give developers more control over the balance between response quality, latency and operating costs.
Frequently Asked Questions
1. What is NVIDIA Nemotron Labs Dory 1.0 4B?
It is a 4-billion-parameter, open-weight language model designed for text-based reasoning, coding and agentic tasks. NVIDIA published it on Hugging Face in October 2026.
2. What is Dory’s context window?
Dory supports a context window of up to 256,000 tokens, according to NVIDIA’s model card.
3. What makes Dory’s architecture different?
It uses a shared recurrent block that can be applied multiple times during inference. Developers can adjust the loop count to trade additional computation for potential performance gains without switching checkpoints.
4. Is Dory a multimodal AI model?
No. Its published specification describes text input and text output, with English as the supported natural language.
5. Can developers run Dory locally?
Potentially, depending on their hardware and compatible inference software. NVIDIA provides BF16, MXFP8, NVFP4 and GGUF variants, but runtime support and memory requirements should be checked before deployment.
6. Is Dory open source?
NVIDIA describes the model as open-weight and publishes downloadable checkpoints under its OpenMDW 1.1 license. Developers should review the license terms rather than assume it is equivalent to a standard open-source software license.
Get the day’s top stories in your inbox
One concise email. No spam, unsubscribe anytime.
