Lesson 1: NemoClaw Fundamentals

Understanding the core components: NemoClaw, OpenShell, OpenClaw, Blueprint, and dcode

The most common confusion is between OpenShell and OpenClaw. Remember: OpenShell is the sandbox (the box); OpenClaw is the agent (what's in the box).

The Big Picture: What Problem Does This Solve?

AI coding agents are powerful but dangerous in enterprise settings. They can:

Accidentally expose API credentials
Access files they shouldn't
Make network requests to unauthorized endpoints
Escalate privileges through shell commands

NemoClaw solves this by providing a governed stack where agents run in isolated sandboxes with strict policy enforcement.

"Teams need full control over tools, context, evaluation methods, runtime location, and action policies - closed ecosystems prevent this." — LangChain Blog

The Five Core Components

Let's define each component precisely before seeing how they connect.

1. NemoClaw

What it is: NVIDIA's open-source reference stack for running sandboxed AI agents safely with a single command.

What it does: CLI tooling for agent onboarding, lifecycle management, versioned blueprint resolution, and SHA-256 digest verification.

Layer: Orchestration (sits at the top)

Source: NVIDIA NemoClaw Documentation

2. OpenShell

What it is: The safe, private runtime for autonomous AI agents - NVIDIA's sandbox technology.

What it does: Defines and enforces the execution environment. Handles sandbox lifecycle, network/filesystem/process policy enforcement, and inference routing.

Layer: Runtime/Sandbox (the container technology)

Key insight: OpenShell IS the sandbox itself.

Source: NVIDIA Ecosystem Docs

3. OpenClaw

What it is: The assistant runtime - tools, memory, and behavior inside the container.

What it does: The default agent that NemoClaw installs. Handles what RUNS inside the sandbox.

Layer: Agent (lives inside OpenShell)

Key insight: OpenClaw is the agent; OpenShell is the sandbox.

Source: NVIDIA Ecosystem Docs

4. Blueprint

What it is: A versioned YAML package that defines what gets deployed.

Contains: (1) Sandbox image (Dockerfile), (2) Policy configuration, (3) Inference profile, (4) Supporting assets

Key properties: Digest-verified (SHA-256), immutable once published, reproducible

Source: NVIDIA How It Works

5. dcode (DeepAgents Code)

What it is: LangChain's CLI for their coding agent, built on the Deep Agents SDK.

What it does: Terminal coding agent that works with ANY LLM. Features persistent memory, customizable skills, human-in-the-loop approval.

Key pattern: Uses "sandbox as tool" - LLM loop runs locally, tool calls target remote sandbox.

Source: LangChain DeepAgents Docs

Visual: The Component Hierarchy

Component Hierarchy (Outside to Inside)

flowchart TB subgraph HOST["HOST MACHINE"] DEV["Developer Terminal
> dcode / > nemoclaw"] subgraph NEMOCLAW["NemoClaw (Orchestration Layer)"] CLI["NemoClaw CLI"] BP["Blueprint Resolver
SHA-256 Verification"] end subgraph OPENSHELL["OpenShell (Sandbox Layer)"] GW["Gateway
(Auth Boundary)"] PE["Policy Engine
(Network/FS/Process)"] PR["Privacy Router
(Credential Store)"] end end subgraph SANDBOX["SANDBOX CONTAINER"] subgraph AGENT["OpenClaw / dcode Agent"] RT["Runtime"] TOOLS["Tools
(python, node, git)"] MEM["Memory"] end SRC["Source Repository"] TESTS["Tests + Dependencies"] end subgraph INFERENCE["MODEL INFERENCE"] INF["inference.local"] PROV["Nemotron 3 Ultra
OpenAI / Anthropic"] end DEV --> CLI CLI --> BP BP --> GW GW --> PE PE --> SANDBOX AGENT --> INF INF -.->|"Credentials injected
on HOST"| PR PR --> PROV style NEMOCLAW fill:#e8f5e9,stroke:#76b900,stroke-width:2px style OPENSHELL fill:#e3f2fd,stroke:#1a5fb4,stroke-width:2px style SANDBOX fill:#fff3e0,stroke:#f57c00,stroke-width:2px style INFERENCE fill:#f3e5f5,stroke:#7b1fa2,stroke-width:2px

Diagram showing the layered architecture. Credentials never enter the sandbox.

Understanding The Image You Shared

Let's map your image to what we've learned:

Your Image Explained

flowchart TB subgraph TITLE["NemoClaw Blueprint for LangChain Deep Agents Code"] direction TB NC["NemoClaw
(Green box at top)"] subgraph OSS["OpenShell Sandbox
(Large dashed box)"] DESC["Repository, tools, commands, tests,
and runtime dependencies live inside"] subgraph INSIDE["Inside the Sandbox"] DCODE["dcode
Coding agent runtime"] REPO["Source repository
Uploaded project files"] SHELL["Shell tools
Commands, package managers"] TDEP["Tests + dependencies
JUnit, Maven, Gradle, COBOL"] end LOOP["Inspect → Edit → Run commands → Test → Summarize"] end subgraph CONTROLS["Security Controls (Yellow boxes)"] POL["Policy controls"] NET["Network controls"] CRED["Credential handling"] LOGS["Logs + snapshots"] end MODEL["NVIDIA Nemotron 3 Ultra
Model endpoint
(Green dashed box)"] end NC --> OSS DCODE <--> REPO DCODE <--> SHELL SHELL <--> TDEP REPO <--> TDEP OSS --> CONTROLS OSS -.->|"Model inference"| MODEL style NC fill:#c8e6c9,stroke:#76b900,stroke-width:3px style OSS fill:#263238,stroke:#76b900,stroke-width:2px,color:#fff style MODEL fill:#c8e6c9,stroke:#76b900,stroke-width:2px,stroke-dasharray: 5 5 style CONTROLS fill:#fff9c4,stroke:#fbc02d,stroke-width:1px

What Each Part Does

Image Component	What It Is	What It Does
NemoClaw (green box, top)	Orchestration layer	Resolves blueprints, verifies digests, calls OpenShell CLI
OpenShell Sandbox (dashed box)	Runtime container	Isolates execution, enforces policies, routes inference
dcode (inside sandbox)	Coding agent runtime	Runs the agent loop (Inspect → Edit → Run → Test → Summarize)
Source repository	Project files	The code the agent is working on (uploaded into sandbox)
Shell tools	Commands, package managers	python, node, git, gh, vim - tools the agent can invoke
Tests + dependencies	Testing frameworks	JUnit, Maven, Gradle - for running tests after edits
Security Controls (yellow boxes)	Policy enforcement	Network/FS/process constraints + credential isolation + logging
Nemotron 3 Ultra (right side)	Model endpoint	Receives inference requests via inference.local (credentials injected on host)

The Agent Loop Explained

The text at the bottom of your image says: Inspect → Edit → Run commands → Test → Summarize

This is the agent loop - the execution cycle that dcode follows:

The Agent Loop

flowchart LR subgraph LOOP["Agent Loop (Inside Sandbox)"] I["1. INSPECT
Read files
Analyze codebase"] E["2. EDIT
Modify source
Write changes"] R["3. RUN
Execute commands
Build, lint, format"] T["4. TEST
Run test suites
Validate changes"] S["5. SUMMARIZE
Compile findings
Report to user"] end I --> E --> R --> T --> S S -.->|"If more work needed"| I style I fill:#e3f2fd,stroke:#1a5fb4 style E fill:#fff3e0,stroke:#f57c00 style R fill:#e8f5e9,stroke:#76b900 style T fill:#f3e5f5,stroke:#7b1fa2 style S fill:#fce4ec,stroke:#c2185b

Source: LangChain DeepAgents Quickstart

How Credentials Stay Safe

One of the most important features: the agent never sees API keys.

Inference Routing Flow

sequenceDiagram participant A as Agent in Sandbox participant I as inference.local participant O as OpenShell (on Host) participant C as Credential Store participant P as Nemotron 3 Ultra A->>I: Request inference
(no credentials) I->>O: Intercepted on host O->>O: Policy engine validates O->>C: Fetch API key C-->>O: Return credentials O->>P: Forward request
(credentials injected) P-->>O: Response O-->>A: Response
(credentials stripped) Note over A,P: Agent NEVER sees raw API keys

Source: NVIDIA Inference Routing Docs

"Provider credentials stay on the host and flow through the OpenShell provider system. The sandbox never receives raw API keys."

How DeepAgents Connects to NemoClaw

DeepAgents (dcode) is the agent harness in the NemoClaw stack:

The Three-Layer Stack

flowchart TB subgraph STACK["NemoClaw Blueprint Stack"] L1["LangChain Deep Agents Code (dcode)
Agent Harness
Planning, memory, tool orchestration"] L2["NVIDIA Nemotron 3 Ultra
Open Model
Tunable, self-hostable, 10x cost savings"] L3["NVIDIA OpenShell Runtime
Governed Sandbox
Policies, security, credential isolation"] end L1 --> L2 --> L3 style L1 fill:#fff3e0,stroke:#f57c00,stroke-width:2px style L2 fill:#f3e5f5,stroke:#7b1fa2,stroke-width:2px style L3 fill:#e3f2fd,stroke:#1a5fb4,stroke-width:2px

"Agent performance improves when the model, harness, evals, and runtime are tuned together." — LangChain Blog

Quick Reference: Who Does What

Component	Layer	Responsibility	Analogy
NemoClaw	Orchestration	Onboarding, lifecycle, blueprint resolution	Building manager (admits tenants)
Blueprint	Configuration	Defines what gets deployed (image, policy, inference)	Lease agreement (terms of tenancy)
OpenShell	Runtime	Sandbox enforcement, policy, credential isolation	The apartment (walls, locks, security)
OpenClaw/dcode	Agent	Execute tasks, use tools, manage memory	The tenant (lives inside)
Nemotron 3 Ultra	Model	Inference (thinking)	The brain (consulted for decisions)

Knowledge Check

Primary Source Reading

For the most authoritative understanding, read: