# NVIDIA NemoClaw

> NVIDIA's reference stack for running third-party agents inside an OpenShell sandbox

- Category: Agents & Automation / Code Sandboxes & Isolation
- Language: TypeScript
- Licence: Apache-2.0
- Repository: https://github.com/NVIDIA/NemoClaw
- Website: https://docs.nvidia.com/nemoclaw/latest/
- Canonical page: https://ai-tldr.dev/tools/nemoclaw/

## In short

NVIDIA NemoClaw is NVIDIA's reference stack for running third-party agents inside an OpenShell sandbox. It sits in the Code Sandboxes & Isolation category of the Agents & Automation tools and is open-source, written in TypeScript and licensed Apache-2.0. To get started: check the prerequisites.

## Overview

NemoClaw is NVIDIA's answer to a question that arrives the moment an autonomous agent is given a shell: where should it run? It is described by the project as "an open source reference stack for running supported AI agents more safely inside NVIDIA OpenShell sandboxes" — not an agent itself, but the boundary and the plumbing around somebody else's agent.

Three agents are supported out of the box: OpenClaw, which is the default, plus Hermes and LangChain Deep Agents Code. Around each of them NemoClaw supplies sandboxed execution inside OpenShell, managed inference so the model endpoint is configured rather than hand-wired, network policy controls over what the sandbox may reach, managed integrations, and snapshots for capturing and restoring sandbox state. Lifecycle operations run through a CLI, with per-agent aliases so the commands read naturally for whichever agent you picked.

It is an Apache-2.0 reference stack rather than a hosted product, and it is specific about where it runs: supported DGX hosts or Windows Subsystem for Linux, with Docker running, Node.js available for the credential helper, and enough disk for the agent image and model you select. Installation goes through a guided onboarding wizard that walks through choosing the agent runtime, an inference provider (local or cloud), optional messaging channels and the security policy, then creates and launches the first sandboxed agent.

## What it does

- Sandboxed agent execution inside NVIDIA OpenShell
- Supports OpenClaw (default), Hermes and LangChain Deep Agents Code
- Managed inference against local or cloud providers, configured during onboarding
- Network policy controls over what the sandboxed agent can reach
- Snapshots of sandbox state, plus managed integrations
- Lifecycle operations through a CLI with per-agent aliases
- Guided onboarding wizard covering runtime, inference, channels and security policy

## Getting started

NemoClaw installs through a maintained last-known-good installer that also runs the onboarding wizard. Check the prerequisites first — the stack targets supported DGX hosts or Windows Subsystem for Linux.

1. Check the prerequisites

   You need a supported OS (Linux, macOS or Windows WSL), Docker installed and running, Node.js 22.19+ if you use the credential helper, administrator or sudo access, enough disk for the chosen agent and model, and network access to pull images and weights.

```bash
docker info
node --version
```

2. Run the installer

   This starts the maintained last-known-good (`lkg`) installer and the onboarding wizard.

```bash
curl -fsSL https://www.nvidia.com/nemoclaw.sh | bash
```

3. Choose your agent runtime

   The wizard asks which supported agent to sandbox. OpenClaw is the default; Hermes and LangChain Deep Agents Code are the other options.

```text
Select agent: OpenClaw (default) / Hermes / LangChain Deep Agents Code
```

4. Pick inference and set policy

   Still in the wizard: select a local or cloud inference provider, configure optional messaging channels, and set the security policy that the sandbox will enforce.

```text
Inference provider → local or cloud
Channels → optional
Security policy → network + integration rules
```

5. Launch the sandboxed agent

   The wizard creates and starts the first sandbox. From there, follow the quickstart for the agent you chose in the NemoClaw documentation, and use the CLI for lifecycle operations and snapshots.

```text
https://docs.nvidia.com/nemoclaw/latest/
```

## When to use it

- Reach for it when an autonomous agent needs shell and network access but must not have it on the host
- Reach for it when you want a network policy in front of an agent rather than trusting its own tool restrictions
- Reach for it when running OpenClaw, Hermes or LangChain Deep Agents Code on DGX hardware or WSL
- Reach for it when you want to snapshot a sandbox so an agent's environment can be restored or reproduced