Run a Fully Open Agent Stack: OpenShell, LangChain Deep Agents, and Nemotron 3

This is part two of our Nemotron series. In part one we looked at Nemotron 3 Ultra and argued that the interesting thing was not the 550 billion parameters, it was the license: NVIDIA shipped the weights, the pretraining data, the post-training recipes, and the RL environments under OpenMDW-1.1. We ended that piece by telling you to point a LangChain Deep Agents loop at the endpoint. On July 8, 2026, NVIDIA and LangChain did exactly that and packaged it. The result is called NemoClaw, and it is the first time every layer of an agent stack (model, harness, and runtime) has been open at the same time.

TL;DR

• NemoClaw is a blueprint, not a product: Nemotron 3 Ultra for the model, LangChain Deep Agents Code for the harness, NVIDIA OpenShell for the sandboxed runtime.
• All three layers are open, and OpenShell is Apache 2.0. Despite the NVIDIA branding, none of it requires an NVIDIA GPU, because GPU support in OpenShell is optional and the model can sit behind any OpenAI-compatible endpoint.
• The headline "10x cheaper" number comes from LangChain's own eval suite, run by the two companies announcing the product, against an unnamed competitor. Treat it as vendor-reported.

What changed since part one

Part one covered a model. This covers the two pieces that were missing around it.

An agent is not a model. It is a model plus a loop that plans, calls tools, remembers things, and keeps going for hours. That loop is the harness. And because the loop runs shell commands and touches files, it needs somewhere safe to do that, which is the runtime. Until now you could get an open model easily and an open harness fairly easily, but the runtime layer was where you quietly ended up on somebody's hosted platform.

NemoClaw fills that gap. The harness is LangChain's Deep Agents Code, shipped as a terminal agent called dcode, in the same category as Claude Code or Codex. The runtime is NVIDIA OpenShell. Both are open, both are self-hostable, and that is the whole story.

OpenShell is the part worth paying attention to

The model gets the headlines, but OpenShell is the piece that did not exist before.

It is a sandbox for autonomous agents, written in Rust, that runs a K3s Kubernetes cluster inside a single Docker container. You do not install Kubernetes separately. Agents run unmodified inside it while OpenShell enforces filesystem, network, and process rules from a declarative YAML policy, and it keeps an audit trail of every allow and deny decision it makes.

That last part matters more than it sounds. Most people running coding agents today either give them full access to a real machine and hope, or run them in a container and lose track of what they actually did. An audit log of denied actions tells you what your agent tried to do, which is exactly the thing you want to know before you let it run unattended for eight hours.

It is also honest about its maturity. NVIDIA describes it as alpha and calls it "single-player mode": one developer, one environment, one gateway. That is not a stack you put in front of a team this quarter.

Getting it running

OpenShell supports Linux, Apple Silicon macOS, and WSL2 (experimental). There are two install paths. The PyPI one:

uv tool install -U openshell

And the official installer, which fetches a release package from GitHub:

curl -LsSf https://raw.githubusercontent.com/NVIDIA/OpenShell/main/install.sh | sh

Then you create a sandbox and run an agent inside it:

openshell sandbox create -- claude
openshell sandbox connect
openshell policy set default --policy policy.yaml

The gotcha nobody documents

The two install paths do not have the same requirements, and we hit this the hard way. The PyPI wheels are built for manylinux_2_39, which means glibc 2.39 or newer. On Debian 11 (glibc 2.31) uv refuses to resolve:

× No solution found when resolving dependencies:
╰─▶ Because all versions of openshell have no wheels with a matching
    platform tag (e.g., `manylinux_2_31_x86_64`) ...
    hint: Wheels are available for `openshell` (v0.0.91) on the following
    platforms: `manylinux_2_39_aarch64`, `manylinux_2_39_x86_64`,
    `macosx_13_0_arm64`

The shell installer is more forgiving. Read the script and it sets its own floor at glibc 2.28, because it installs a Debian or RPM package rather than a Python wheel. So on an older distro the uv path fails and the install.sh path works. The tradeoff is that the package install needs root and registers a systemd user service, which is a bigger commitment than a user-local tool.

If you are on Ubuntu 24.04 or later, or a current Fedora, both paths work and this never comes up.

Pointing the harness at Nemotron

Deep Agents Code installs with its own script:

curl -LsSf https://langch.in/dcode | bash

It is model-agnostic, which is the useful bit. Any provider that speaks tool calling works, and providers are declared in config.toml. Since Nemotron 3 Ultra is served over an OpenAI-compatible API, you register it like any other provider. Adapted from LangChain's documented schema:

[models]
default = "openrouter:nvidia/nemotron-3-ultra-550b-a55b:free"

[models.providers.openrouter]
display_name = "OpenRouter"
api_key_env = "OPENROUTER_API_KEY"
base_url = "https://openrouter.ai/api/v1"
models = ["nvidia/nemotron-3-ultra-550b-a55b:free"]
enabled = true

[models.providers.openrouter.params]
temperature = 0

One useful detail: dcode checks DEEPAGENTS_CODE_{NAME} before falling back to {NAME} for credentials. So you can set DEEPAGENTS_CODE_OPENROUTER_API_KEY and give the agent its own key without touching what every other tool on your machine uses.

Putting the harness inside the sandbox

Here is the part the announcement glosses over. OpenShell's four headline agents (Claude Code, OpenCode, Codex, Copilot CLI) are not a whitelist, they are the ones that come pre-installed in the base image with credentials auto-discovered from your shell. Everything after -- on sandbox create is passed verbatim to the container, so any binary runs. dcode simply is not one of the pre-baked ones, which means you put it in the image yourself.

That is what --from is for. It takes a community image name, a local directory with a Dockerfile, or any container image reference:

# build a sandbox image that has dcode installed
openshell sandbox create --from ./my-dcode-sandbox --name nemo -- dcode

# register the model endpoint explicitly, since auto-discovery
# only covers the four pre-installed agents
openshell provider create

Two flags worth knowing while you are here. --policy attaches your YAML rules at creation time, and --gpu requests GPU passthrough, which is opt-in. That last one is the clearest evidence that the GPU is genuinely optional rather than quietly assumed.

You do not need to self-host 550B to try this. OpenRouter carries a free Nemotron 3 Ultra endpoint at 200 requests per day with the full 1M context, which is enough to see whether the harness fits how you work. Paid pricing is $0.50 per million input tokens and $2.20 per million output. The free tier logs requests, so keep anything confidential off it.

About that 10x number

The announcement's headline claim is that Nemotron 3 Ultra under Deep Agents scored an aggregate 0.86 at $4.48 of inference cost, against $43.48 for "the next closest model."

Read that carefully. It is LangChain's own eval suite. It was run by the two companies announcing the product. The competitor is not named, and no third party has replicated it. None of that makes it false, and the underlying economics are plausible, since a 55B-active MoE really is cheaper to serve than a dense frontier model. But an unnamed baseline in a vendor benchmark is a number you quote with attribution, not one you plan a budget around.

The claim we would actually stand behind is the boring one: you can run this stack yourself, inspect every layer, and swap any of them out. That does not need a benchmark.

Limitations and gotchas

• OpenShell is alpha. NVIDIA says so directly. Single developer, single environment, single gateway.
• The glibc split above. Old distro, use the shell installer, expect to need root.
• dcode is not a pre-installed OpenShell agent, though it still runs. Only Claude Code, OpenCode, Codex and Copilot CLI ship in the base image with credentials auto-discovered, so getting the harness into the sandbox is on you. See the section above.
• Self-hosting the model is a datacenter problem. Nemotron 3 Ultra needs a multi-GPU node even at NVFP4, as covered in part one. The realistic setup for most people is open harness and open runtime locally, model over an API.
• Free-tier limits. 200 requests per day disappears fast when an agent runs a long task with many tool calls.

Who should use it

If you are building agents you intend to run unattended, on data you care about, OpenShell is worth an afternoon on its own, independent of anything NVIDIA. It is Apache 2.0 and it works with agents you already use.

If you are shopping for an agent stack you can audit end to end, with no layer you cannot inspect or replace, NemoClaw is currently the only complete answer. Just size the alpha warning honestly.

If you want a coding agent that works today, this is not that. Use what you already have and revisit when OpenShell leaves alpha.

The ten-minute move: install dcode, point it at the free Nemotron endpoint with the config block above, and give it one real task. That tells you whether the harness suits you before you invest in the runtime.

What we are watching next

Three things for the next entry in this series. Whether OpenShell picks up multi-user support, which is what turns it from a developer tool into infrastructure. Whether anyone independently replicates the cost claim. And whether the next Nemotron ships with the same open data and recipes, because that, not the parameter count, is what made part one worth writing.

Sources and further reading

• Part one: Nemotron 3 Ultra, a fully open 550B agent model
• LangChain: NemoClaw Deep Agents blueprint announcement
• NVIDIA: Nemotron with the LangChain Deep Agents harness
• NVIDIA OpenShell on GitHub (Apache 2.0)
• OpenShell documentation
• OpenShell: supported agents and base image contents
• OpenShell: managing sandboxes and the --from flag
• LangChain deepagents on GitHub
• Deep Agents Code documentation
• Nemotron 3 Ultra free endpoint on OpenRouter

Tested on: not independently tested end to end. We verified the install paths on Debian 11 (Intel i7-10510U, 6 cores, no GPU) and confirmed the glibc 2.39 wheel requirement and the installer's 2.28 floor from the release script. We did not run an agent under OpenShell: the PyPI path will not resolve on glibc 2.31, and the package path requires a root install of alpha software. Benchmark figures are vendor-reported by LangChain and NVIDIA and are labeled as such above.
Date tested: 2026-07-25