OpenClaw on NemoClaw

The OpenClaw assistant on NVIDIA's NemoClaw runtime — agent lifecycle, policy engine, and OpenShell sandbox — backed by a locally-served LLM on Dell deskside hardware.

Summary

NemoClaw is NVIDIA's runtime for autonomous, tool-using AI agents: agent lifecycle, declarative policy engine, OpenShell sandbox. This solution binds it to a locally-served LLM (vLLM, tuned public-image recipes in this repo) so the full agent loop — reasoning, tool execution, policy enforcement — stays on your Dell workstation, no cloud dependency. NemoClaw onboards a supported agent — by default OpenClaw, the open-source assistant — so what this solution actually runs is OpenClaw on NemoClaw; swap in your own agent or Hermes on the same base. Dell adds S/M/L sizing, serving recipes, validation numbers, and fleet guidance on top of NVIDIA's NemoClaw playbooks and the RTX Local AI hub.

This is the base runtime. For the shipping tool-using agent, use Hermes on NemoClaw — Hermes runs on this substrate. Teams building their own agents start here.

Personas

Reference NVIDIA playbooks

Use cases

What NemoClaw is not: not the agent (your logic, or Hermes), not a hosted service, not an LLM, not a policy language.

Architecture

Two independent planes, wired together by one command:

The agent loop, end to end:

        Your custom agent (agent logic runs here)
                     │
      ┌──────────────▼───────────────────────────────┐
      │  Plane 2 — NemoClaw runtime                  │
      │    agent lifecycle ── MCP client             │
      │    policy engine ─── gates fs / net / subproc│
      │    OpenShell sandbox (k3s + landlock)        │
      └────┬─────▲─────────────────────┬─────────────┘
tool_use   │     │ tool result         │ completions
           ▼     │                     ▼
   Sandboxed tools /       Plane 1 — vLLM /v1 (OpenAI-compatible, :8000)
   MCP servers                      │
   (credentialed,             Prometheus :9090 ◄─ Grafana :3000
    outside sandbox)            (scrape vLLM /metrics)

        Dell deskside system (S: GB10 / T2 · M: T4 · L: GB300 / T6)

Components. NemoClaw runtime — agent lifecycle: create / list / connect sandboxes, wire providers, apply policy. OpenShell — secure sandbox on k3s: long-running sessions, filesystem landlock, L7 network policy, subprocess isolation. Policy engine — declarative per-sandbox rules; shipped tiers strict (read-only allowlist, whitelisted egress, no subprocess) → standard (enterprise default) → permissive (never in production).

Plane 1 uses only public images, pinned in recipes/versions.lock (vLLM, Prometheus, Grafana, LiteLLM); Plane 2 installs via NVIDIA's shipping installer, tracking NVIDIA's release cadence.

S / M / L sizing

Sizing framework: S/M/L Sizing. Custom agents follow this envelope for the LLM half; tool-execution cost adds on top — measure it.

Model recommendation

Tool-calling quality is a hard requirement for agent workloads. Every pick below has verified tool calling on the exact serving flags shown; mismatched tool/reasoning parsers break tool-calling silently.

• S default: nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-NVFP4 — MoE, NVFP4, GB10 → GB300. M/L default: Nemotron 3.5 Super VL (Lightning multi-instance is the measured fallback). Parsers: --enable-auto-tool-choice --tool-call-parser qwen3_coder --reasoning-parser nemotron_v3 (baked into the recipes).
• S alt: nvidia/Qwen3.8-27B-NVFP4 (+ MTP) — recipes/gb10/vllm/docker-qwen3.8-27b-nvfp4.sh; parsers qwen3_coder / qwen3.
• M alt: nvidia/Qwen3.8-Flash-Next-NVFP4 (MTP ×3, engram CPU offload) — recipes/precision/vllm/docker-qwen3.8-flash-next-nvfp4.sh; parsers qwen3_xml / qwen3.
• L alt: RedHatAI/GLM-5.3-Flash-NVFP4 (320B/18B-active MoE, 262K ctx) — recipes/gb300/vllm/docker-glm-5.3-flash-nvfp4.sh; parsers glm47 / glm45.

Inference stack

vLLM (preferred) — OpenAI-compatible, production-grade, the basis for all sizing numbers; tuned recipes apply:

--kv-cache-dtype fp8 --max-num-seqs 32/256/512 --max-model-len 200000
--enable-auto-tool-choice --tool-call-parser qwen3_coder
--reasoning-parser nemotron_v3
_Commands in this guide run from the repository root (`git clone` this repo and `cd` into it)._

Tool-calling reference: https://docs.vllm.ai/. Ollama / NIM: Inference Stack & Models.

Deployment recipes

Catalog: docs/recipes/. Two-step quick start (for a fleet, scripts/landscape/deploy-solution.sh runs both steps):

# 1. Plane 1 — serve the local LLM
recipes/<platform>/vllm/docker-nemotron-3.5-lightning-nvfp4.sh --port 8000
curl -s http://localhost:8000/v1/models

# 2. Plane 2 — NemoClaw installer + OpenShell
curl -fsSL https://www.nvidia.com/nemoclaw.sh | bash
export PATH="$HOME/.local/bin:$PATH"

# 3. Wire agent inference to Plane 1
openshell provider create --name vllm-local --type openai \
  --credential OPENAI_API_KEY=local \
  --config base_url=http://host.docker.internal:8000/v1
openshell inference set --provider vllm-local --model nvidia/nemotron-3.5-lightning
openshell status              # Connected

Full guides: Developer Deploy Guide · IT-Admin Guide.

Benchmarks & performance (validation)

S-tier reference platform (Dell Precision T2 class, RTX PRO 6000 Blackwell 96 GB, Nemotron 3.5 Lightning NVFP4).

Serving layer (raw vLLM, aiperf, concurrency 1 → 256, 0 request errors):

Agent layer (real agent turn — plan → tool_call → recover → finalize: 3 POST /v1/chat/completions calls in ~3 s of LLM time, ~4 s wall clock; grounded tool exec verified end-to-end). Hermes-shaped harness, default model, 100 % task success:

Guidance: GB10 1–2 concurrent interactive agents (4 batch); T2 1–4; T4 1–4; T6 1–4 per GPU (one instance per GPU behind a router); GB300 1–4+, headroom above the tested range. S-tier serving ceiling ~32–64 concurrent interactive requests. Validated on reference hardware; your workloads will vary.

Management environment

• Fleet: Ubuntu Landscape script execution for Plane 1 rollout.
• Identity: your gateway / reverse proxy for AD/LDAP-backed auth on multi-user tiers.
• Monitoring: every Plane 1 recipe starts the shared tokenomics Prometheus + Grafana (monitoring/README.md: tokens, cloud-equivalent vs on-prem cost, utilisation, TTFT, KV cache, queue). KV-cache > 90 % sustained (alert shipped) → shorten context or cut concurrency. NemoClaw agent telemetry is not collected by this repo.

Dependencies & risk factors

• Dependencies: NemoClaw + OpenShell NVIDIA installer (NVIDIA's cadence); vLLM on GB10 / RTX PRO Blackwell / GB300; HF access to Nemotron 3.5 Lightning NVFP4; tool-call-capable lineup above.
• Risk factors: tool-execution cost is design-dependent and can dominate LLM cost; model-specific tool-parser flags.

Related

• Hermes on NemoClaw — shipping tool-using agent on this runtime.
• Agentic Coding · Agentic Video Search & Summarization — companions sharing the Plane 1 endpoint.
• docs/recipes/ · Dell Deskside Agentic AI Solutions — catalog, repo overview.