[NVIDIA Research] Nemotron-Terminal: Transforming LLMs into CLI Powerhouses through Data Engineering

As Large Language Models (LLMs) evolve from passive chat interfaces to active software engineering agents, the Terminal has become the ultimate workspace. However, while proprietary tools like Claude Code and OpenAI's Codex CLI hint at high proficiency, the "secret sauce" of their training data remains hidden.

In a new breakthrough paper, researchers from NVIDIA and the Laude Institute present Nemotron-Terminal, a family of models that proves you don't need a trillion parameters to master the command line—you just need the right data.

TL;DR

• The Innovation: A two-stage pipeline called Terminal-Task-Gen for scaling agentic data.
• The Result: Nemotron-Terminal-32B beats the 480B Qwen3-Coder on Terminal-Bench 2.0.
• The Secret: Combining broad "Dataset Adapters" with "Skill-based" synthetic tasks that cover 9 distinct terminal domains.

The Problem: Why Terminals are Hard for LLMs

Most LLMs are trained on static code or textbooks. But terminal interaction is a dynamic, multi-turn sequence where the model must interpret shell feedback, manage state, and handle environmental "side effects" (like file permissions or dependency conflicts).

Existing datasets are either too narrow or lack the "gold trajectories" showing how to recover from errors. This creates a data scarcity bottleneck that prevents smaller models from reaching agentic maturity.

Methodology: The "Coarse-to-Fine" Data Strategy

The authors propose a principled dual-strategy to bridge this gap.

1. Dataset Adapters (Coarse Scaling)

Instead of starting from scratch, the team repurposed high-quality reasoning datasets (Math, Code, SWE). They built "adapters" that wrap these prompts into a terminal-bench format, essentially asking the agent to solve a math problem or fix a bug by interacting with a shell.

2. Terminal-Task-Gen (Fine-Grained Synthesis)

To teach specific "terminal-native" skills, they developed a synthetic pipeline. They defined a Skill Taxonomy across 9 domains (Security, SysAdmin, Debugging, etc.) and asked a teacher model (DeepSeek-V3.2) to brainstorm tasks that require 3-5 of these skills at once.

Figure 1: Overview of the Terminal-Task-Gen framework, showcasing how seed data and skill taxonomies are transformed into Dockerized trajectory traces.

Scalability through Docker

One major technical insight is the use of 9 pre-built domain-specific Docker images. Most previous works tried to build a custom Dockerfile for every single task, which is slow and prone to build failures. By using stable, pre-configured environments (e.g., a "Data Science" image with pandas and scikit-learn), the researchers could scale trajectory generation without constant infrastructure overhead.

Experiments & Results: Efficiency Wins

The results on Terminal-Bench 2.0 (a grueling benchmark of 89 real-world tasks) are striking. Nemotron-Terminal-32B achieved 27.4%, which is not only a massive leap from the base Qwen3-32B (3.3%), but also superior to the massive 480B Qwen3-Coder.

Table 1: Competitive performance of Nemotron-Terminal against proprietary and massive open-weights models.

Key Breakthrough Areas:

The synthetic data unlocked specific functional utilities that base models lacked entirely:

• Data Processing: Jumped from 5.0% to 50.0%.
• Data Querying: Jumped from 0.0% to 60.0%.
• Security: Jumped from 2.5% to 27.5%.

Critical Insight: To Filter or Not to Filter?

In a surprising finding (Ablation Study), the authors discovered that not filtering trajectories worked best for terminal agents. Typically, researchers only keep "successful" trajectories. However, here, "no filter" (keeping both successful and incomplete attempts) yielded a performance of 9.66% vs. 8.09% for successful-only. This suggests that teaching a model the process of exploration is valuable even if the final goal isn't reached in the teacher's trace.

Conclusion and The Future of Autonomous Agents

The Nemotron-Terminal family represents a significant step toward democratizing high-performance agents. By open-sourcing the models and the Terminal-Corpus dataset, NVIDIA has provided the community with a baseline that rivals the industry's largest closed models.

What's next? The authors point toward Reinforcement Learning (RL). Since terminal tasks are inherently verifiable (the script either works or it doesn't), the next frontier is using these SFT foundations as a starting point for self-correcting RL agents.

Check out the models and dataset on Hugging Face: nvidia/nemotron-terminal