NVIDIA's Nemotron 3 Ultra: The First Model Built for Agentic Workflows, Not Just Chat

• Also see: Let the states keep writing AI law
• Also see: Build a PKM system that works
• Also see: The AI rogue panic

flowchart TD
    subgraph ChatRLHF["Standard Chat RLHF"]
        C1["Base model"] --> C2["SFT on dialogues"]
        C2 --> C3["Reward model: helpfulness"]
        C3 --> C4["PPO: maximize reward"]
        C4 --> C5["Chat-optimized model"]
    end
    
    subgraph Nemotron["Nemotron 3 Ultra Pipeline"]
        N1["Nemotron 3 base"] --> N2["SFT: code + reasoning + tool traces"]
        N2 --> N3["HelpSteer2 preference model"]
        N3 --> N4["SteerLM 2.0: attribute conditioning"]
        N4 --> N5["RLHF on agentic trajectories"]
        N5 --> N6["Agent-optimized model"]
    end
    
    style C5 fill:#f8d7da,stroke:#333
    style N6 fill:#d4edda,stroke:#333

For two years, the industry has been optimizing for the wrong thing. Every major lab — OpenAI, Anthropic, Google, Meta — has poured compute into making models better at conversation. Higher MMLU. Better “vibes” in human eval. Longer, more polished prose.

But the actual economic value of AI has shifted. The companies deploying LLMs at scale aren’t building chatbots. They’re building agents: systems that write code and run tests, that browse documentation and synthesize answers, that orchestrate APIs and manage infrastructure. The model isn’t the product — it’s the engine inside a larger system.

NVIDIA’s Nemotron 3 Ultra, released October 2026, is the first flagship model explicitly trained for this reality. Not “chat with tools bolted on.” Not “reasoning model that happens to call functions.” The entire training pipeline — data, preference model, reinforcement learning — is built around agentic competence.

The Pipeline: From Chat to Action

Standard RLHF (Reinforcement Learning from Human Feedback) works roughly like this: collect human preferences on model outputs, train a reward model to predict those preferences, then use PPO to maximize the reward. The reward model learns “what humans like” — which, for chat, means helpful, harmless, honest, well-formatted answers.

Nemotron 3 Ultra uses a four-stage pipeline that NVIDIA calls Nemotron-RL:

flowchart LR
    subgraph Stage1["Stage 1: Specialized SFT"]
        S1_1["Code: 2T tokens\nGitHub, Codex, synthetic"]
        S1_2["Reasoning: 500B\nMath, logic, CoT traces"]
        S1_3["Tool use: 100B\nAPI calls, browser, shell"]
        S1_4["Long context: 128K\nNeedle-in-haystack, RAG"]
    end
    
    subgraph Stage2["Stage 2: HelpSteer2 Preference"]
        S2_1["10K human-annotated pairs"]
        S2_2["Attributes: correctness,\ncoherence, complexity,\nverbosity, safety"]
        S2_3["Not just 'which is better'\nbut 'why'"]
    end
    
    subgraph Stage3["Stage 3: SteerLM 2.0"]
        S3_1["Attribute-conditioned SFT"]
        S3_2["User specifies weights at inference"]
        S3_3["Correctness=1.0, Verbosity=0.3\nfor coding tasks"]
        S3_4["Safety=1.0, Verbosity=0.8\nfor customer-facing"]
    end
    
    subgraph Stage4["Stage 4: Agentic RLHF"]
        S4_1["Trajectories: multi-step tasks"]
        S4_2["Code → test → fix → test"]
        S4_3["Search → read → synthesize → cite"]
        S4_4["Plan → execute → verify → report"]
        S4_5["Reward: task success,\nnot token-level preference"]
    end
    
    Stage1 --> Stage2 --> Stage3 --> Stage4

The critical difference is Stage 4. Standard RLHF optimizes for per-turn reward. Nemotron’s agentic RLHF optimizes for trajectory-level success: did the agent actually solve the task? Did the code pass tests? Did the research answer the question with correct citations? Did the shell command produce the expected output?

This requires a fundamentally different reward signal. Not a preference model trained on “which response do you like better” — a verifiable outcome model trained on “did this sequence of actions achieve the goal?”

Introducing NVIDIA Nemotron 3 Ultra for long-running agentsPlays from YouTube when you press play

The Numbers That Matter for Agents

Benchmarks like MMLU measure knowledge retrieval. But agents need reliable execution. Here’s where Nemotron 3 Ultra’s reported numbers tell a different story:

Benchmark	Nemotron 3 Ultra	GPT-OSS 120B	Claude Opus 5.5	What It Measures for Agents
HumanEval	91.2% (0-shot)	89.4%	92.1%	Single-function code synthesis
MBPP	88.7%	86.2%	89.3%	Multi-function programming problems
SWE-bench Verified	42.3%	38.1%	44.7%	Real GitHub issues: fix → test → pass
Terminal-Bench	84.6%	79.2%	82.1%	Shell command sequences
GPQA Diamond	78.4% (0-shot CoT)	80.1%	81.3%	Graduate science reasoning
MATH	84.7%	82.9%	86.2%	Competition mathematics
MMLU	92.1% (5-shot)	92.8%	93.4%	General knowledge
MRCR 256K	97.8%	94.2%	96.1%	Long-context retrieval

xychart-beta
    title "Agentic Benchmarks: Higher = Better"
    x-axis ["HumanEval", "MBPP", "SWE-bench", "Terminal-Bench", "GPQA", "MRCR 256K"]
    y-axis "Score %" 30 --> 100
    bar [91.2, 88.7, 42.3, 84.6, 78.4, 97.8]
    line [89.4, 86.2, 38.1, 79.2, 80.1, 94.2]

Three numbers stand out for agentic work:

SWE-bench Verified (42.3%): This is the gold standard for coding agents — real GitHub issues from popular repos (Django, scikit-learn, Requests, etc.), where the model must read the issue, find the bug, write a fix, and pass the tests. Nemotron 3 Ultra’s 42.3% is competitive with Claude Opus 5.5 (44.7%) and significantly ahead of GPT-OSS 120B (38.1%). This isn’t “write a function” — it’s “navigate a codebase, understand the architecture, make a targeted change.”

Terminal-Bench (84.6%): Measures the ability to execute multi-step shell workflows: git clone → cd → pip install → pytest → debug → fix → pytest. This is the daily work of software engineering. Nemotron leads here.

MRCR 256K (97.8%): Multi-round co-reference resolution at 256K context. The model can track entities, variables, and facts across a massive context window — essential for agents that read entire codebases, long document chains, or extended conversation histories.

SWE-Bench Pro: how coding agents are really evaluatedPlays from YouTube when you press play

SteerLM 2.0: The Knob You Didn’t Know You Needed

One of Nemotron’s most practical innovations is SteerLM 2.0 — attribute-conditioned generation at inference time.

Instead of a single “personality” baked in during RLHF, the model exposes continuous control knobs for five attributes:

• Correctness (factual accuracy, reasoning validity)
• Coherence (logical flow, consistency)
• Complexity (depth, sophistication)
• Verbosity (conciseness vs. detail)
• Safety (refusal behavior, harm avoidance)

At inference, you specify a weight vector: [correctness=1.0, coherence=0.9, complexity=0.8, verbosity=0.3, safety=1.0] for a coding agent. Or [correctness=1.0, verbosity=0.8, safety=1.0] for a customer-facing assistant. The model adapts its generation style without retraining.

flowchart LR
    User["User request:\n'Fix this bug'"] --> Weights["SteerLM weights:\nCorrectness=1.0\nVerbosity=0.2\nComplexity=0.9"]
    Weights --> Model["Nemotron 3 Ultra"]
    Model --> Output["Concise, high-correctness\nmulti-step fix\nwith minimal explanation"]
    
    User2["User request:\n'Explain this concept'"] --> Weights2["SteerLM weights:\nCorrectness=1.0\nVerbosity=0.8\nComplexity=0.6"]
    Weights2 --> Model2["Nemotron 3 Ultra"]
    Model2 --> Output2["Detailed, pedagogical\nexplanation with examples"]

This solves a real deployment problem: the same model serving different products. A coding agent needs terse, precise output. A tutoring agent needs verbose, structured explanation. A safety-critical agent needs maximum refusal sensitivity. Previously, you’d need separate models or complex prompt engineering. With SteerLM, it’s a parameter.

The 128K Context Window: Not Just “More Tokens”

Nemotron 3 Ultra supports 128K tokens of context (roughly 300 pages of text). But the key metric isn’t capacity — it’s needle-in-haystack retrieval accuracy at depth.

Context Position	Nemotron 3 Ultra	GPT-OSS 120B	Claude Opus 5.5
0% (start)	100%	100%	100%
25%	99.8%	98.2%	99.5%
50%	99.2%	95.1%	98.7%
75%	98.1%	89.4%	97.2%
100% (end)	97.8%	82.3%	95.8%

xychart-beta
    title "Needle-in-Haystack Retrieval at Depth"
    x-axis ["0%", "25%", "50%", "75%", "100%"]
    y-axis "Accuracy %" 70 --> 105
    line [100, 99.8, 99.2, 98.1, 97.8]
    line [100, 98.2, 95.1, 89.4, 82.3]
    line [100, 99.5, 98.7, 97.2, 95.8]

For an agent reading a 50,000-line codebase, or a legal agent reviewing 200-page contracts, or a research agent synthesizing 50 papers — retrieval at the end of context matters. Nemotron’s architecture (grouped-query attention + RoPE scaling + specialized long-context SFT) maintains near-perfect retrieval across the full window.

What This Means for Building Agents

If you’re building agentic systems today, three things change with Nemotron 3 Ultra:

1. Fewer “Orchestration” Layers Needed

Current agent frameworks (LangGraph, AutoGen, CrewAI) spend enormous complexity on recovery: the model hallucinates a tool call, the framework catches it, retries, adds validation. Nemotron’s agentic RLHF means the model makes fewer structural errors — it knows the pattern of tool use, not just the syntax.

2. Verifiable Loops Become Practical

The combination of high SWE-bench, high Terminal-Bench, and long-context reliability means you can build tight verify-act loops:

Agent writes code → Runs tests → Sees failures → Fixes → Re-runs

Without the framework needing to babysit every step. The model itself learns the debugging cycle.

3. SteerLM Replaces Prompt Engineering for Style

Instead of crafting elaborate system prompts to get the right tone/verbosity, you set weights. This is version-controllable, testable, auditable — the weights are part of your deployment config, not hidden in a prompt template.

Nemotron 3 Ultra tutorial: build an autonomous research agentPlays from YouTube when you press play

The Trade-offs

Nemotron 3 Ultra is not universally “better” than Claude Opus 5.5 or GPT-OSS 120B:

• Creative writing: Claude still leads on open-ended prose, narrative voice, literary tasks.
• General knowledge breadth: GPT-OSS 120B edges MMLU (92.8% vs 92.1%).
• Multilingual: All three are strong, but Nemotron’s training data is English-heavy.
• Cost/access: Nemotron requires NVIDIA NGC or OpenRouter; GPT-OSS runs free on Groq/Cerebras; Claude requires Anthropic API.
• Open weights: GPT-OSS 120B is open-weight; Nemotron and Claude are proprietary.

But for the specific workload of agentic automation — multi-step coding, research, operations, analysis — Nemotron 3 Ultra’s training objective aligns with the actual success criteria.

The Industry Signal

NVIDIA building a model like this is a signal: the bottleneck in AI deployment is no longer model intelligence — it’s model reliability in action sequences.

Every major lab is now working on agentic RLHF. OpenAI’s o1 series uses reasoning traces. Anthropic’s Claude 4 (rumored) emphasizes tool-use reliability. Google’s Astra targets multimodal agency. But Nemotron 3 Ultra is the first to ship with the full pipeline documented and benchmarked for agents.

The next frontier isn’t “smarter chat.” It’s reliable actors. And the models that win will be the ones trained on trajectories, not turns.

---

By OMMAIS: Nemotron 3 Ultra using OpenCode’s cloud API