NVIDIA and LangChain tune Nemotron 3 Ultra for agents

NVIDIA and LangChain have introduced a dedicated LangChain Deep Agents configuration for Nemotron 3 Ultra, NVIDIA’s language model for complex tasks. The significance lies less in a new round of model training than in the method: performance has been improved by changing the agent’s instructions, tools and execution environment.

According to NVIDIA, the configuration delivers the highest accuracy among open models on LangChain’s public Deep Agents benchmark and reaches parity with the highest-scoring closed models on business tasks. The company also says its inference cost per run is ten times lower than that of leading closed models.

An agent is more than just the model

An AI agent is a system that does more than generate text: it can retrieve information, use software tools, retain context and chain together steps to complete a task. In these systems, the model is an important component, but it does not work alone.

LangChain focused its tuning on what it calls the harness, the environment that coordinates the agent. The team analyzed Nemotron 3 Ultra’s execution traces in its test suite to identify the steps where it lost points. It then adjusted the system prompts, tool descriptions and middleware that orchestrates the agent’s calls.

According to the announcement, there was no retraining or fine-tuning of the model’s weights. That distinction matters for enterprises: retraining a large model requires data, compute capacity and time, while improving the orchestration layer can be faster and within reach of product teams.

The result should not be interpreted as meaning that an open model has broadly outperformed every proprietary model. The figures come from the Deep Agents benchmark and measure behavior within that evaluation framework. Real-world usefulness will depend on each organization’s connected tools, internal data, tasks and controls.

An open stack for deployment and control

The work is being distributed through NemoClaw for LangChain Deep Agents, NVIDIA’s open reference blueprint. It combines Deep Agents code adapted for Nemotron 3 Ultra with OpenShell, a runtime designed to ensure agent actions are carried out with security controls in place.

The approach is intended to let an enterprise control all three layers of the system: the model, the mechanism that coordinates tools and memory, and the environment where actions are executed. That is particularly important when agents access corporate applications, databases or processes that affect customers and operations.

An open stack does not eliminate risks on its own. An agent can still misinterpret an instruction, select an unsuitable tool or act with excessive permissions. That is why the ability to inspect and modify every layer is valuable only when paired with continuous evaluations, access limits and review of sensitive actions.

Cost determines which agents reach production

NVIDIA says the tuned profile can complete more tasks at higher throughput and at one-tenth the inference cost of leading closed models. If those savings are confirmed in companies’ own deployments, they could change the economics of agents: organizations could test more configurations, evaluate their systems continuously and reserve more expensive models for cases where they deliver a measurable advantage.

LangChain says its platform has more than 200 million monthly downloads, a scale that makes this integration a significant distribution channel for NVIDIA. The tuned profile is already available through LangChain, while Nemotron 3 Ultra is available as a hosted offering on Baseten, Crusoe Cloud, DeepInfra, Fireworks, Nebius and Together AI.

The next test will not be the benchmark, but sustained use in real-world processes. Organizations will need to measure not only how many tasks the agent completes, but also how much it costs to supervise, what errors it makes and whether control over an open stack outweighs the added responsibility of operating it.

A harness change can look like a change in intelligence

The NVIDIA tutorial describes a loop: run the evaluation, read traces, propose instruction or middleware changes and run the test again. That method can fix real failures. It can also overfit the system to a known set if the same tasks guide every decision. A held-out group that designers do not see until the end is therefore necessary.

Model, prompt, tool descriptions, memory, execution loop and environment form the evaluated system. Changing any of them can alter the result without touching weights. A reproducible comparison must version every layer and retain traces. Saying only “Nemotron 3 Ultra” removes part of the intervention that produced the score.

Testing whether improvement transfers

First divide tasks into development and a closed test. Then classify failures by cause: missing information, wrong tool, wrong argument, incomplete reading, unauthorised action or defective final answer. A fix should improve its category without worsening another. Multiple runs reveal variability that one score hides.

The cost claim needs a denominator. “One-tenth” may refer to token price per run, but a cheap agent that repeats steps or needs more supervision may cost more per solved task. Add calls, tokens, time, infrastructure, review and error recovery, and compare only results that meet the same quality threshold.

The open Deep Agents repository permits harness inspection and version pinning. Openness helps audit and modification; it does not make permissions safe. An agent needs its own identity, least privilege, spending limits, confirmation before irreversible actions and a record a person can reconstruct.

Tool descriptions deserve their own test. Ambiguous wording can make a model choose a write operation when reading was enough, confuse identifiers or omit a parameter. Every tool should state preconditions, effects, errors, reversibility and negative examples. The evaluation can then include pairs of similar tools to check whether the agent distinguishes their boundaries. Improving a description may raise accuracy without changing the model, but it also expands the contract the team must maintain when the API evolves.

Memory adds another component. Keeping everything increases context and exposure; summarising may lose a constraint. Tests should include changing instructions, secrets that must not reappear and long goals, then check what the agent remembers, for how long and who can delete it. Better continuity is not worth deploying if it retains data the user expected to withdraw. Deletion should be verifiable and logged without reproducing the sensitive content.

The production test

Before deployment, an organisation can select frequent and adversarial tasks, set success criteria, and measure completion, accuracy, human intervention, cost and possible harm. It then runs the new and old profiles on the same cases without telling reviewers which is which. Only then should a change enter a limited environment.

The transferable skill is to evaluate an agent as a versioned stack instead of attributing everything to the model. Better instructions can be valuable, but the gain must survive new tasks, repetition, complete costs and authority limits.