Building AI Agents with NVIDIA NemoClaw and NeMo Agent Toolkit — A Complete Tutorial

Jensen Huang spent two hours at GTC 2026 convincing the world that we have entered the era of agentic AI. But announcements on a stage in San Jose do not ship products. Code does. If you watched the keynote, you saw NemoClaw demonstrated as the secure runtime for autonomous agents. If you read my analysis of the GTC 2026 keynote, you understand the strategic significance. Now it is time to build something.

This tutorial walks you through the full NVIDIA agentic AI stack, from installing the NeMo Agent Toolkit to configuring NemoClaw sandbox policies to deploying multi-agent workflows that run on Nemotron models. By the end, you will have a working agent system that can execute multi-step tasks with enterprise-grade security guardrails.

What You Will Build

We are building a research agent system that can accept a topic, search for relevant information, synthesize findings into a structured report, and deliver it through a secured NemoClaw runtime. The system uses three coordinated agents:

1. Research Agent — Gathers information from configured sources
2. Analysis Agent — Processes raw data into structured findings
3. Report Agent — Generates formatted output with citations

This is not a toy demo. The architecture mirrors what enterprises are deploying in production right now, and the security model is what separates NemoClaw from every other agent framework on the market.

Prerequisites

Before starting, make sure you have the following ready:

• Python 3.11, 3.12, or 3.13 — The NeMo Agent Toolkit requires one of these versions
• Node.js 18+ — NemoClaw itself is a TypeScript plugin for OpenClaw
• Docker — Required for sandbox isolation
• NVIDIA API Key — Free tier available at build.nvidia.com
• 8GB+ RAM — Minimum for running local agent workflows
• Git — For cloning the toolkit and examples

Optional but recommended:

• NVIDIA GPU (RTX 3060 or better) — Required only for local NIM inference
• uv package manager — Faster than pip for Python dependency management

Part 1 — Understanding the Architecture

Before writing any code, you need to understand how the three layers of the NVIDIA agentic AI stack interact.

Layer 1: NeMo Agent Toolkit (The Brain)

The NeMo Agent Toolkit is a Python library that handles agent orchestration. Think of it as the logic layer — it defines what agents do, how they communicate, and what tools they have access to. The toolkit provides:

• Workflow definitions via YAML configuration files
• Agent classes with customizable behavior
• Tool integrations for search, computation, and API calls
• Multi-agent coordination through message passing

The toolkit runs agents as Python processes and coordinates their execution through a central orchestrator.

Layer 2: NemoClaw (The Security Shell)

NemoClaw wraps the entire agent system in a security sandbox. Every agent runs inside an isolated Docker container with a YAML-defined policy that controls:

• Network access — Which endpoints each agent can reach
• File system access — Which directories are readable and writable
• Inference routing — Where model calls go (cloud, local, or hybrid)
• Resource limits — CPU, memory, and GPU allocation per agent

This is the layer that makes NemoClaw different from LangChain, CrewAI, or AutoGen. Those frameworks handle orchestration. NemoClaw handles security. In production, you need both.

Layer 3: Inference (The Models)

NVIDIA provides three inference paths:

1. NVIDIA Cloud — Route to Nemotron 3 Super 120B via build.nvidia.com
2. Local NIM — Run a NIM container on your own GPU hardware
3. Third-party — Connect to any OpenAI-compatible API endpoint

The beauty of this design is that you can develop against the NVIDIA Cloud API (free tier) and then switch to local NIM containers for production without changing your agent code. The inference profile is a configuration setting, not a code change.

Part 2 — Installing the NeMo Agent Toolkit

Let us start with the foundation layer. The NeMo Agent Toolkit is the Python SDK that you will use to define agent behavior and workflows.

Step 1: Clone the Repository

git clone -b main https://github.com/NVIDIA/NeMo-Agent-Toolkit.git
cd NeMo-Agent-Toolkit

Step 2: Set Up the Python Environment

The toolkit recommends using uv for dependency management, but pip works too:

# Option A: Using uv (recommended)
uv venv --python 3.12 --seed .venv
source .venv/bin/activate
uv sync --all-groups --all-extras

# Option B: Using pip
python3.12 -m venv .venv
source .venv/bin/activate
pip install -e ".[all]"

Step 3: Verify the Installation

nat --version
# Expected output: NeMo Agent Toolkit 1.5.x

nat --help
# Shows available commands: serve, run, config, etc.

The nat command is the primary CLI interface for the NeMo Agent Toolkit. You will use it to run workflows, serve agent APIs, and manage configurations.

Step 4: Set Your API Key

Create a .env file in the project root:

echo "NVIDIA_API_KEY=nvapi-your-key-here" > .env

Get your free API key at build.nvidia.com. The free tier includes 1,000 API calls per month, which is more than enough for development and testing.

Part 3 — Your First Agent Workflow

The NeMo Agent Toolkit uses YAML files to define agent workflows. This is a deliberate design choice — it separates agent logic from configuration, making it easy to modify behavior without touching code.

The Simple Calculator Example

Let us start with the included calculator example to understand the workflow structure:

nat serve --config_file=examples/getting_started/simple_calculator/configs/config.yml

This starts an agent server that exposes an HTTP API. In a separate terminal, you can interact with it:

curl -X POST http://localhost:8000/run \
  -H "Content-Type: application/json" \
  -d '{"input": "What is 42 multiplied by 17, then divided by 3?"}'

The agent will decompose the math problem into steps, execute each calculation using a tool, and return the result. Let us examine the configuration that makes this work.

Anatomy of a Workflow Configuration

# config.yml
workflow:
  name: calculator-agent
  description: An agent that performs mathematical calculations

  agents:
    - name: calculator
      model: nvidia/nemotron-3-super-120b
      system_prompt: |
        You are a precise mathematical calculator.
        Break complex problems into individual operations.
        Always show your work step by step.
      tools:
        - name: calculator
          type: python
          module: tools.calculator

  inference:
    provider: nvidia-cloud
    api_key: ${NVIDIA_API_KEY}
    endpoint: https://integrate.api.nvidia.com/v1

Every workflow configuration has three sections:

1. workflow — Name, description, and the list of agents
2. agents — Each agent gets a name, model, system prompt, and tool list
3. inference — Where model calls are routed

Part 4 — Building the Research Agent System

Now let us build something real. We are creating a three-agent research system that accepts a topic, gathers information, analyzes it, and produces a structured report.

Project Structure

Create a new directory for your project:

mkdir research-agent-system
cd research-agent-system

Set up the following file structure:

research-agent-system/
├── config.yml          # Workflow configuration
├── tools/
│   ├── __init__.py
│   ├── search.py       # Web search tool
│   ├── analyze.py      # Data analysis tool
│   └── report.py       # Report generation tool
├── prompts/
│   ├── researcher.txt  # Research agent system prompt
│   ├── analyst.txt     # Analysis agent system prompt
│   └── reporter.txt    # Report agent system prompt
└── .env                # API keys

Step 1: Define the Workflow Configuration

# config.yml
workflow:
  name: research-agent-system
  description: Multi-agent system for topic research and report generation
  version: '1.0'

  agents:
    - name: researcher
      model: nvidia/nemotron-3-super-120b
      system_prompt_file: prompts/researcher.txt
      tools:
        - name: web_search
          type: python
          module: tools.search
          config:
            max_results: 10
            timeout: 30
      max_iterations: 5
      temperature: 0.3

    - name: analyst
      model: nvidia/nemotron-3-super-120b
      system_prompt_file: prompts/analyst.txt
      tools:
        - name: data_analyzer
          type: python
          module: tools.analyze
      max_iterations: 3
      temperature: 0.2

    - name: reporter
      model: nvidia/nemotron-3-super-120b
      system_prompt_file: prompts/reporter.txt
      tools:
        - name: report_generator
          type: python
          module: tools.report
      max_iterations: 2
      temperature: 0.4

  orchestration:
    type: sequential
    pipeline:
      - agent: researcher
        output_key: raw_research
      - agent: analyst
        input_key: raw_research
        output_key: analysis
      - agent: reporter
        input_key: analysis
        output_key: final_report

  inference:
    provider: nvidia-cloud
    api_key: ${NVIDIA_API_KEY}
    endpoint: https://integrate.api.nvidia.com/v1
    retry:
      max_attempts: 3
      backoff_seconds: 2

Let us break down what is new here compared to the calculator example.

The orchestration section defines how agents communicate. We are using a sequential pipeline where each agent receives the output of the previous one. The output_key and input_key fields control data flow between agents.

The max_iterations setting limits how many reasoning steps each agent can take. This prevents runaway loops and controls token usage.

The temperature varies by agent — lower for the researcher (we want factual accuracy) and slightly higher for the reporter (we want readable prose).

Step 2: Write the Agent System Prompts

Each agent needs a carefully crafted system prompt that defines its role, capabilities, and output format.

Research Agent (prompts/researcher.txt):

You are a research specialist. Your job is to gather comprehensive
information on a given topic using the web_search tool.

INSTRUCTIONS:
1. Break the topic into 3-5 specific search queries
2. Execute each search query using the web_search tool
3. For each result, extract: title, source URL, key facts, and relevance score
4. Compile all findings into a structured JSON output

OUTPUT FORMAT:
{
  "topic": "the research topic",
  "queries_executed": ["query1", "query2", ...],
  "findings": [
    {
      "title": "Finding title",
      "source": "URL",
      "key_facts": ["fact1", "fact2"],
      "relevance": 0.0-1.0
    }
  ],
  "summary": "2-3 sentence overview of what was found"
}

RULES:
- Always use the web_search tool. Never fabricate sources.
- Aim for 8-12 unique findings per research session.
- Prioritize recent sources (prefer last 6 months).
- Include diverse perspectives when the topic is controversial.

Analysis Agent (prompts/analyst.txt):

You are a data analyst. You receive raw research findings and produce
structured analysis with patterns, trends, and insights.

INSTRUCTIONS:
1. Review all research findings for quality and relevance
2. Identify 3-5 major themes or patterns across the findings
3. For each theme, provide supporting evidence from the research
4. Rate confidence level for each insight (high/medium/low)
5. Identify any gaps or contradictions in the research

OUTPUT FORMAT:
{
  "themes": [
    {
      "name": "Theme name",
      "description": "What this theme means",
      "evidence": ["source1 says X", "source2 confirms Y"],
      "confidence": "high|medium|low"
    }
  ],
  "contradictions": ["Description of any conflicting information"],
  "gaps": ["Areas where more research is needed"],
  "key_statistics": [{"stat": "description", "value": "number"}]
}

RULES:
- Base all analysis strictly on the provided research data.
- Never introduce information not present in the input.
- Flag low-confidence insights explicitly.

Report Agent (prompts/reporter.txt):

You are a technical report writer. You receive analyzed data and produce
a polished, readable report with proper citations.

INSTRUCTIONS:
1. Create an executive summary (3-4 sentences)
2. Write a detailed findings section organized by theme
3. Include a data table for key statistics
4. Add a recommendations section based on the analysis
5. Append a sources section with all referenced URLs

OUTPUT FORMAT:
Markdown report with the following sections:
# [Topic] Research Report

Executive Summary

Key Findings

[Theme 1]

[Theme 2]

Data Overview

Recommendations

Sources

RULES:

• Write for a technical audience with business context.
• Every claim must reference a specific finding from the analysis.
• Keep the total report between 1,500 and 2,500 words.

### Step 3: Implement the Tools

Each tool is a Python module that the agents can call during execution.

**Search Tool** (`tools/search.py`):

```python
"""Web search tool for the research agent."""

from typing import Any
import httpx
import os


async def web_search(
    query: str,
    max_results: int = 10,
    timeout: int = 30,
) -> dict[str, Any]:
    """Execute a web search and return structured results.

    Args:
        query: The search query string.
        max_results: Maximum number of results to return.
        timeout: Request timeout in seconds.

    Returns:
        Dictionary containing search results with titles, URLs, and snippets.
    """
    api_key = os.environ.get("SEARCH_API_KEY", "")

    async with httpx.AsyncClient(timeout=timeout) as client:
        response = await client.get(
            "https://api.search.brave.com/res/v1/web/search",
            headers={"X-Subscription-Token": api_key},
            params={
                "q": query,
                "count": max_results,
                "text_decorations": False,
            },
        )
        response.raise_for_status()
        data = response.json()

    results = []
    for item in data.get("web", {}).get("results", []):
        results.append({
            "title": item.get("title", ""),
            "url": item.get("url", ""),
            "snippet": item.get("description", ""),
            "age": item.get("age", ""),
        })

    return {
        "query": query,
        "result_count": len(results),
        "results": results,
    }

Analysis Tool (tools/analyze.py):

"""Data analysis tool for the analyst agent."""

from typing import Any
from collections import Counter
import re


def analyze_findings(
    findings: list[dict[str, Any]],
) -> dict[str, Any]:
    """Analyze research findings for patterns and statistics.

    Args:
        findings: List of research finding dictionaries.

    Returns:
        Dictionary containing statistical analysis of the findings.
    """
    total_findings = len(findings)
    sources = [f.get("source", "") for f in findings]
    unique_domains = set()
    for source in sources:
        match = re.search(r"https?://([^/]+)", source)
        if match:
            unique_domains.add(match.group(1))

    relevance_scores = [
        f.get("relevance", 0.5) for f in findings
    ]
    avg_relevance = (
        sum(relevance_scores) / len(relevance_scores)
        if relevance_scores
        else 0
    )

    all_facts = []
    for f in findings:
        all_facts.extend(f.get("key_facts", []))

    word_freq = Counter()
    for fact in all_facts:
        words = re.findall(r"\b[a-zA-Z]{4,}\b", fact.lower())
        word_freq.update(words)

    return {
        "total_findings": total_findings,
        "unique_sources": len(unique_domains),
        "average_relevance": round(avg_relevance, 3),
        "total_facts_extracted": len(all_facts),
        "top_keywords": word_freq.most_common(20),
        "source_domains": sorted(unique_domains),
    }

Report Tool (tools/report.py):

"""Report generation tool for the reporter agent."""

from typing import Any
from datetime import datetime


def generate_report_metadata(
    topic: str,
    theme_count: int,
    source_count: int,
    confidence_distribution: dict[str, int],
) -> dict[str, Any]:
    """Generate metadata for the research report.

    Args:
        topic: The research topic.
        theme_count: Number of identified themes.
        source_count: Number of unique sources.
        confidence_distribution: Count of high/medium/low confidence insights.

    Returns:
        Dictionary containing report metadata and quality score.
    """
    quality_score = 0.0
    quality_score += min(theme_count / 5, 1.0) * 30
    quality_score += min(source_count / 10, 1.0) * 30
    high_confidence_ratio = confidence_distribution.get("high", 0) / max(
        sum(confidence_distribution.values()), 1
    )
    quality_score += high_confidence_ratio * 40

    return {
        "topic": topic,
        "generated_at": datetime.now().isoformat(),
        "theme_count": theme_count,
        "source_count": source_count,
        "confidence_breakdown": confidence_distribution,
        "quality_score": round(quality_score, 1),
        "quality_rating": (
            "excellent" if quality_score >= 80
            else "good" if quality_score >= 60
            else "needs_improvement"
        ),
    }

Step 4: Run the Workflow

With everything in place, run the research agent system:

# From your project directory
nat run --config_file config.yml \
  --input "Analyze the current state of enterprise AI agent adoption in 2026"

You will see output like this in your terminal:

[researcher] Starting research on: enterprise AI agent adoption in 2026
[researcher] Executing search: "enterprise AI agent adoption 2026 statistics"
[researcher] Executing search: "fortune 500 AI agent deployments"
[researcher] Executing search: "agentic AI framework market share 2026"
[researcher] Found 12 relevant findings across 8 sources
[analyst] Analyzing 12 findings...
[analyst] Identified 4 major themes with 3 high-confidence insights
[reporter] Generating report...
[reporter] Report complete: 1,847 words, quality score: 82.3/100

The entire pipeline takes 30 to 90 seconds depending on your inference provider and the complexity of the topic.

Part 5 — Securing Agents with NemoClaw

You have a working agent system. Now let us make it production-ready by wrapping it in NemoClaw's security sandbox. This is the critical step that most agentic AI tutorials skip, and it is the reason enterprises cannot deploy frameworks like LangChain without additional infrastructure.

Why Agent Security Matters

An autonomous agent with access to web search, file systems, and APIs is a powerful tool. It is also a potential attack vector. Without sandboxing:

• A prompt injection could instruct the agent to exfiltrate data
• A malicious search result could redirect the agent to a harmful endpoint
• An agent with file write access could modify system configurations
• Unbounded inference calls could exhaust API quotas

NemoClaw solves all of these problems with a defense-in-depth approach.

Step 1: Install NemoClaw

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

The installer checks for Node.js (installs it if missing) and runs the onboard wizard. Follow the prompts to:

1. Accept the Apache 2.0 license
2. Set your NVIDIA API key
3. Choose a default inference profile
4. Create your first sandbox configuration

After installation, verify:

nemoclaw --help
# Shows commands: launch, connect, status, logs, policy, etc.

Step 2: Create the Sandbox Policy

NemoClaw uses YAML policy files to define what agents can and cannot do. Create a policy for our research agent system:

# openclaw-sandbox.yaml
version: '1.0'
name: research-agent-sandbox

security:
  isolation: docker
  network:
    allowed_endpoints:
      - 'api.search.brave.com'
      - 'integrate.api.nvidia.com'
      - 'build.nvidia.com'
    denied_endpoints:
      - '*' # Deny everything not explicitly allowed
    max_connections_per_agent: 5

  filesystem:
    readable:
      - '/app/config/'
      - '/app/prompts/'
      - '/app/tools/'
    writable:
      - '/app/output/'
    denied:
      - '/etc/'
      - '/var/'
      - '/root/'

  resources:
    max_memory_mb: 2048
    max_cpu_percent: 50
    max_inference_calls: 100
    max_tokens_per_call: 4096
    timeout_seconds: 300

  privacy:
    redact_pii: true
    log_level: 'info'
    audit_trail: true

agents:
  researcher:
    network:
      allowed_endpoints:
        - 'api.search.brave.com'
    resources:
      max_inference_calls: 30

  analyst:
    network:
      allowed_endpoints: [] # No network access needed
    resources:
      max_inference_calls: 20

  reporter:
    network:
      allowed_endpoints: [] # No network access needed
    resources:
      max_inference_calls: 50

This policy implements the principle of least privilege. The researcher agent can access the search API, but the analyst and reporter agents have no network access at all — they only work with data passed to them through the pipeline. Every agent has hard limits on memory, CPU, and inference calls.

Step 3: Configure Inference Profiles

NemoClaw ships with three inference profiles in the blueprint.yaml file. Let us configure ours:

# blueprint.yaml
inference_profiles:
  cloud:
    provider: nvidia-cloud
    model: nvidia/nemotron-3-super-120b
    endpoint: https://integrate.api.nvidia.com/v1
    api_key: ${NVIDIA_API_KEY}
    settings:
      max_tokens: 4096
      temperature: 0.3

  local:
    provider: nim
    model: nemotron-3-super-120b
    endpoint: http://localhost:8080/v1
    settings:
      max_tokens: 4096
      temperature: 0.3

  fallback:
    provider: openai-compatible
    model: meta/llama-3.1-70b-instruct
    endpoint: https://integrate.api.nvidia.com/v1
    api_key: ${NVIDIA_API_KEY}
    settings:
      max_tokens: 4096
      temperature: 0.3

active_profile: cloud
fallback_profile: fallback

The active_profile setting determines which model your agents use. During development, use cloud for access to Nemotron 3 Super 120B without local hardware. For production with sensitive data, switch to local to keep all inference on your own infrastructure.

The fallback_profile activates automatically if the primary inference endpoint fails — a resilience pattern that prevents agent workflows from crashing due to transient API issues.

Step 4: Launch the Secured Agent System

# Launch NemoClaw with your policy and config
nemoclaw launch \
  --policy openclaw-sandbox.yaml \
  --blueprint blueprint.yaml \
  --config config.yml

# Check status
nemoclaw status
# Output:
# Sandbox: research-agent-sandbox (running)
# Agents: 3 (researcher, analyst, reporter)
# Inference: cloud (nemotron-3-super-120b)
# Policy: enforced
# Uptime: 12s

Now interact with the secured system:

nemoclaw connect

# Inside the NemoClaw shell:
> run "What are the security implications of autonomous AI agents in healthcare?"

Watch the logs in another terminal to see the security policy in action:

nemoclaw logs --follow

# Output shows policy enforcement:
# [policy] researcher: network request to api.search.brave.com — ALLOWED
# [policy] researcher: network request to external-api.com — DENIED
# [policy] analyst: network access attempt — DENIED (no network allowed)
# [policy] reporter: inference call 1/50 — ALLOWED
# [policy] audit: pipeline complete, 47 inference calls, 0 policy violations

Part 6 — Multi-Agent Orchestration Patterns

The sequential pipeline we built is one orchestration pattern. The NeMo Agent Toolkit supports several others that are useful for different use cases.

Pattern 1: Sequential Pipeline (What We Built)

orchestration:
  type: sequential
  pipeline:
    - agent: researcher
    - agent: analyst
    - agent: reporter

Best for: Linear workflows where each step depends on the previous one. Research, analysis, and reporting is the classic example.

Pattern 2: Parallel Execution

orchestration:
  type: parallel
  agents:
    - name: news_researcher
      topic: 'breaking AI news'
    - name: market_researcher
      topic: 'AI market data'
    - name: academic_researcher
      topic: 'recent AI papers'
  merge_strategy: concatenate

Best for: Gathering information from multiple independent sources simultaneously. Three researchers work at the same time, and their results are merged before analysis.

Pattern 3: Router (Conditional)

orchestration:
  type: router
  classifier: intent_classifier
  routes:
    technical: technical_agent
    business: business_agent
    general: general_agent
  default: general_agent

Best for: Handling diverse input types. A classifier agent determines the intent, then routes to a specialized agent. This is how customer support systems work — route billing questions to the billing agent, technical questions to the support agent.

Pattern 4: Hierarchical (Manager-Worker)

orchestration:
  type: hierarchical
  manager: project_manager
  workers:
    - researcher
    - analyst
    - reporter
    - fact_checker
  manager_can_delegate: true
  max_delegation_depth: 2

Best for: Complex tasks where a manager agent decides which workers to engage and in what order. The manager can dynamically adjust the workflow based on intermediate results.

Part 7 — Working with Local NIM Inference

For production deployments where data cannot leave your infrastructure, you will want to run inference locally using NVIDIA NIM containers. This requires an NVIDIA GPU but gives you complete control over your data.

Step 1: Pull the NIM Container

docker pull nvcr.io/nim/nvidia/nemotron-3-super-120b:latest

Note: This container is large (approximately 80GB for the full 120B parameter model). For development, consider the smaller Nemotron variants:

# Smaller models for development
docker pull nvcr.io/nim/nvidia/nemotron-3-8b:latest      # ~16GB
docker pull nvcr.io/nim/nvidia/nemotron-3-22b:latest     # ~44GB

Step 2: Launch the NIM Container

docker run -d \
  --name nemotron-nim \
  --gpus all \
  -p 8080:8080 \
  -e NGC_API_KEY=${NGC_API_KEY} \
  nvcr.io/nim/nvidia/nemotron-3-super-120b:latest

Step 3: Verify the NIM is Running

curl http://localhost:8080/v1/models
# Should list the nemotron model

curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "nemotron-3-super-120b",
    "messages": [{"role": "user", "content": "Hello"}],
    "max_tokens": 100
  }'

Step 4: Switch NemoClaw to Local Inference

# Update the active profile
nemoclaw config set active_profile local

# Restart the sandbox
nemoclaw restart

That is it. Your agents now run entirely on your infrastructure. No data leaves your network. The agent code does not change — only the inference configuration.

Part 8 — Framework Comparison

If you have used LangChain, CrewAI, or AutoGen before, you are probably wondering where NemoClaw fits. The answer is that it does not replace those frameworks — it complements them.

The Stack Model

Think of the agentic AI stack in layers:

| Layer | Purpose | Tools | | ----------------- | --------------------------- | ---------------------------------------------- | | Orchestration | Agent logic, chains, tools | LangChain, CrewAI, AutoGen, NeMo Agent Toolkit | | Security | Sandboxing, policies, audit | NemoClaw, OpenShell | | Inference | Model serving | NIM, vLLM, TGI, OpenAI API | | Hardware | Compute | NVIDIA GPUs, cloud instances |

The NeMo Agent Toolkit competes at the orchestration layer. NemoClaw operates at the security layer. You can actually run LangChain agents inside a NemoClaw sandbox — NVIDIA explicitly supports this through framework plugins.

# Using LangChain inside NemoClaw
workflow:
  framework: langchain
  entry_point: my_langchain_chain.py

The NeMo Agent Toolkit also has native plugins for LangChain, LlamaIndex, CrewAI, Microsoft Semantic Kernel, and Google ADK. This means you can mix frameworks within a single NemoClaw deployment.

As I discussed in my prediction on NemoClaw reaching 60 percent enterprise adoption by Q1 2027, the security layer is what will drive enterprise adoption. Companies are not struggling with agent orchestration — they are struggling with agent governance. NemoClaw fills that gap.

Part 9 — Production Deployment Checklist

Before deploying your agent system to production, walk through this checklist:

Security

• Sandbox policy reviewed and tightened for production endpoints
• All network access is explicitly allowed (deny-by-default)
• File system access limited to required paths only
• PII redaction enabled
• Audit trail logging enabled
• Resource limits set based on load testing

Inference

• Inference profile tested with production model
• Fallback profile configured and tested
• API key rotation schedule established
• Rate limits configured per agent

Monitoring

• NemoClaw logs shipping to your observability platform
• Alerts configured for policy violations
• Token usage tracking enabled
• Latency monitoring per agent step

Resilience

• Fallback inference profile tested
• Circuit breaker timeouts configured
• Agent restart policies defined
• Data persistence configured for intermediate results

Part 10 — Troubleshooting Common Issues

Issue: "Sandbox failed to start"

This usually means Docker is not running or the Docker socket is not accessible:

# Check Docker status
docker info

# If Docker Desktop, make sure it is running
# If Linux, check the daemon
sudo systemctl status docker

Issue: "Inference timeout"

The Nemotron 3 Super 120B model can take 10-15 seconds for complex prompts on the cloud API. Increase your timeout:

# In config.yml
inference:
  timeout_seconds: 60

Issue: "Policy violation: network access denied"

Your agent is trying to reach an endpoint not in the allowed list. Check the logs:

nemoclaw logs --filter policy

Add the required endpoint to your openclaw-sandbox.yaml file, then restart:

nemoclaw restart

Issue: "Module not found" for tools

Make sure your tools directory has an __init__.py file and is mounted into the sandbox:

# In openclaw-sandbox.yaml
filesystem:
  readable:
    - '/app/tools/'

What Comes Next

You now have a working multi-agent system running inside a NemoClaw security sandbox. The natural next steps are:

1. Add more tools — Connect databases, APIs, and file processors to your agents
2. Experiment with orchestration patterns — Try parallel execution or hierarchical management for complex workflows
3. Set up local NIM inference — Move to on-premises inference for sensitive data
4. Build custom policies — Create per-department or per-use-case sandbox policies
5. Integrate with existing frameworks — Run your LangChain or CrewAI agents inside NemoClaw

The full code for this tutorial is available at github.com/CrashBytes/nemoclaw-research-agent-tutorial.

For more context on the NVIDIA ecosystem these tools live in, read my analysis of NVIDIA's full-stack AI takeover strategy at GTC 2026. And if you are new to building AI agents in general, start with my tutorial on building agents with the Claude Agent SDK for a complementary perspective using a different stack.

The agentic AI era is not coming. It is here. The question is whether you will build on a foundation that can scale to production, or whether you will spend the next year retrofitting security onto an agent system that was never designed for it. NemoClaw gives you the secure foundation from day one.