Jensen Huang's Latest Interview: The Operating System for Next-Generation Software Companies Is Harness

In his latest 26-minute interview, Jensen Huang never mentioned GPUs or computing power. He focused on one single shift: programmers should move from writing code to building Agents. LangChain optimized its workflow using Nemotron 3 Ultra paired with Harness, pushing its Deep Agents benchmark score to 0.86 — just 0.01 behind the top result — while slashing the per-run cost from $43.48 to $4.48. The model itself stayed the same. What changed was the system surrounding it.

No GPU talk for 26 minutes: What is Jensen Huang avoiding?

In his latest public interview, Jensen Huang did not mention GPUs, computing power, or new model parameters at all.

He spoke with Harrison Chase, the founder of LangChain, for 26 minutes. The entire conversation revolved around one question: when Agents start to call tools and execute workflows on behalf of humans, where should companies allocate their engineering resources?

His answer was direct: write less repetitive code, and build more Agents that can actually get things done.

This is no empty slogan. Huang compared coding to typing: typing skill is important, but it never makes a writer. Similarly, writing a snippet of Python code still matters, but it no longer equals delivering a functional Agent system.

Engineers must also decide what the Agent can observe, what tools it can invoke, how it recovers from failures, and who validates its outputs.

Generating code only solves the "write it down" part. Agent engineering must further ensure the system can run correctly, behave reliably, recover from errors, and leave a traceable audit trail.

Harness: the overlooked "workbench" surrounding the model

Jensen Huang repeatedly emphasized one term: Harness.

It encompasses prompts, tool specifications, memory systems, context management, task decomposition, retry logic, evaluation pipelines, and access control. The model handles reasoning, while the Harness organizes that reasoning into verifiable, deliverable work.

Publicly available data confirms that LangChain ran Nemotron 3 Ultra on the Deep Agents benchmark without retraining the model weights. It only adjusted system prompts, tool descriptions, and middleware layers.

The result: the benchmark score climbed to 0.86 from its baseline, while the top closed-source model sits at 0.87.

The gap is only 0.01.

Yet the per-run cost dropped from $43.48 to $4.48 — nearly a 10× reduction.

This chart shows that the exact same model will demonstrate vastly different capabilities when placed inside different Harness implementations. Comparing Agent systems by model leaderboard alone is no longer sufficient.

For engineering teams, execution traces are becoming as critical as test logs. They reveal exactly where points were lost in an evaluation, and turn isolated failures into new regression test cases.

Over time, accumulated prompts, tool interfaces, execution traces, and evaluation datasets become a company's core Agent engineering assets.

10× cheaper does not only cut bills — it rewrites development methods

Jensen Huang noted that lower costs do not simply make existing work cheaper. They fundamentally change how teams develop.

A single Agent task often requires multiple rounds of reasoning, calls to many different tools, and parallel exploration of alternative paths. When each trial is expensive, teams naturally cut back on evaluation and experimentation.

Lower costs first unlock the ability to "experiment broadly" — simultaneously comparing models, prompts, tool configurations, and retry strategies.

The second new capability is "continuous testing" — embedding evaluation into daily development workflows and production monitoring.

The third capability is "wider deployment" — extending Agents that once only served a handful of high-value tasks into many more niche operational processes.

A reasonable projection: when Harness tuning for open models becomes sufficiently affordable, companies will adopt a pattern: use cutting-edge models to explore new use cases, then specialize the workflow for high-frequency tasks.

When a problem is new and its boundaries are unclear, frontier models are ideal for discovering the upper limits of what is possible. Once the task becomes repetitive and acceptance criteria stabilize, teams can then converge it into a far cheaper, purpose-built Agent.

This "specialization" does not happen only inside model weights.

What truly sets organizations apart is their proprietary library of tool descriptions, business terminology, permission boundaries, historical execution traces, and validation datasets. These components together define whether an Agent truly understands how that specific company operates.

Future companies will run on Harness — but never hand over master keys directly to Agents

Jensen Huang put forward a provocative thesis: future organizations will build an increasing share of their operational capabilities on top of Harness.

In the past, companies encoded workflows inside ERPs, CRMs, and rigid approval rule engines. In the Agent era, many workflows will shift to a new paradigm: define a goal, available tools, permissions, and acceptance criteria, then let the system plan its own execution path. Harness becomes the new container that hosts these business rules.

This also explains why the open stack is repeatedly emphasized. Enterprises want full ownership of their memory systems, execution traces, evaluation datasets, and tuning data — and full control over which infrastructure these assets run on.

But once an Agent can access terminals, databases, and internal APIs, it is no longer just a chatbot — it becomes a software process with the power to act on real systems.

The NemoClaw architecture combines the Deep Agents Code engine, Nemotron 3 Ultra, and the OpenShell runtime. The model handles reasoning, Harness orchestrates tasks, and OpenShell places all code execution inside a sandbox, enforcing granular policies for network access, credentials, files, and logs.

Jensen Huang's bottom line is unambiguous: Agents should never be granted long-term persistent credentials. The correct approach is for the runtime to inject temporary, task-specific permissions dynamically, so the Agent can only access necessary resources for the minimum required time and scope.

At the engineering implementation level, teams must answer at least four questions: on whose behalf is the Agent acting, which commands are permitted, how can operations be halted or rolled back on failure, and who can audit the full execution trace.

Without these guardrails, the more capable an Agent becomes, the larger the organization's exposure to risk.

Do not treat Agents as colleagues — they are first and foremost controlled software

Harrison Chase raised a sensitive question: as Agents collaborate in natural language and behave increasingly like humans, to what degree should we anthropomorphize them?

Jensen Huang's response was pragmatic. Natural language makes interaction smoother, but it must never blur lines of accountability. An Agent can have a persona and a name, but its confident tone never makes its outputs automatically correct — and no one should ever skip permission checks or validation just because it "feels like a teammate."

To verify an Agent has completed a task, rely on objective, external evidence: did tests pass, do diffs match expectations, was data written to the correct location, and are approval records complete?

When it says "the task is done," that is nothing more than an output waiting to be validated.

Anthropomorphism can help teams reason about collaboration patterns, but engineering management must remain de-personified: every tool call must have a verifiable identity, every high-risk action must be governed by a policy, and every final result must pass through a validator.

Rumors in the community suggest some companies are experimenting with assigning Agents "virtual employee IDs" and formal reporting hierarchies. Publicly available documentation confirms these practices remain experimental, and no industry-wide consensus has emerged around them.

The programmer's to-do list is being reordered

Jensen Huang's take on employment follows his classic supply-side logic: when the cost of delivering a digital service falls, society does not settle for the same volume of output. It unlocks massive new demand for use cases that were previously unaffordable or deprioritized.

For programmers, the real change is not "will there still be code to write" — it is that the priority of tasks is being reshuffled.

Boilerplate code, format conversion, and repetitive debugging will increasingly be delegated to Agents. Task definition, system design, evaluation pipeline construction, permission governance, and exception handling will grow in importance.

This observation does not guarantee every existing role will survive unchanged. As software supply expands, new work will shift from manually completing every step to designing systems that reliably complete tasks on their own.

Whether an individual benefits from this transition depends on whether they can cross this threshold of responsibility.

The missing piece is not a better model — it is a complete Agent stack

Putting Jensen Huang's interview together produces a full engineering blueprint:

The model handles reasoning, Harness handles planning, memory, and tool orchestration, the runtime handles isolation and secure execution, and Evals plus Guardrails verify that results are safe to deliver.

Remove any layer, and your Agent will never progress beyond the demo stage.

This architecture also defines a clear implementation sequence for teams: first build evaluations using real-world tasks, then get the model and Harness running; next add sandboxes, identity controls, logging, and human override capabilities; and only then discuss large-scale deployment and cost optimization.

Models will continue to improve, but what companies need to cultivate long-term is the engineering environment surrounding the model — the layer deeply tied to their unique data, tools, and accountability boundaries.

The Harness that Jensen Huang describes may very well become the most critical foundational layer for the next generation of software companies.

Closing Thoughts

The most notable part of this interview is that Huang shifted the conversation away from "which model is stronger" and back to "how do we build the system properly."

LangChain's benchmark results provide a concrete example: 0.86 vs 0.87, and $4.48 vs $43.48. The gap is not in the model. It is in the Harness.

As Agents move from demos to production, the core of enterprise competition will shift from "what model are you using" to "can you reliably embed your business workflows, permission boundaries, and acceptance criteria into an iterable, evaluable, auditable system."

Harness is that container. The first organizations to build it correctly will make Agents true operational team members — not just chatbot novelties trapped inside a window.