ckg-nvidia-nemoclaw

NVIDIA NemoClaw as a traversable knowledge graph — MCP-native

NemoClaw shows you which agent is burning your budget. CKG reduces the burn.

The graph doesn't guess — it traverses. Every answer traces to a declared edge.

PyPI → · Benchmark → · graphifymd.com →

The graph

graph TD
    NC[NemoClaw] --> OS[OpenShell]
    NC --> OC[OpenClaw]
    NC --> HM[Hermes]
    NC --> LC[LangChain Deep Agents]
    NC --> MCP[ManagedMCPServer]
    NC --> AH[AgentHeartbeat]

    OC --> PTD[ProgressiveToolDisclosure]
    HM --> PTD
    LC --> PTD

    OS --> L7[L7Proxy]
    OS --> LL[LandlockLSM]
    OS --> CP[CONNECT_Proxy]

    L7 --> SG[SharedGateway]
    SG --> IP[InferenceProvider]
    IP --> vLLM[vLLM]
    IP --> OLL[Ollama]
    IP --> NIM[NIM_Local]
    IP --> MR[ModelRouter]

    MCP --> NP[NetworkPolicy]
    MCP --> L7

    NP --> PT[PolicyTier]
    NP --> PP[PolicyPreset]
    PP --> TG[Telegram]
    PP --> DC[Discord]
    PP --> SL[Slack]

    SH[SecurityHardening] --> SB[Sandbox]
    SH --> LL
    SH --> BP[NemoClaw_Blueprint]

    NIM --> DGX[DGX_Spark]

    style NC fill:#0f6e56,color:#fff
    style PTD fill:#1a5c47,color:#fff
    style SH fill:#1a5c47,color:#fff
    style NP fill:#1a5c47,color:#fff
    style IP fill:#2d7a5e,color:#fff

What developers are actually hitting

Across GitHub issues, HN threads, and hands-on walkthroughs, three NemoClaw pain signals dominate:

1. Context bloat in tool loops. Agents using OpenClaw, Hermes, or LangChain Deep Agents accumulate context across tool calls until the window fills and the session degrades. The bloat isn't the tools — it's that the model re-infers NemoClaw's architecture on every query instead of reading it from a declared structure.

2. "Which agent is burning my budget?" Routing inference through OpenShell makes token spend visible per agent for the first time — developers can suddenly see the burn. The next question is how to reduce it.

3. The Policy Source Gap. NVIDIA's own OpenShell knowledge graph names this explicitly: Policy Source Gap — the missing layer between the runtime policy engine and the structured domain knowledge agents need to make compliant decisions. The graph declares the gap. We filled it.

This package is that layer.

What it is

55 nodes · 74 edges · the full NemoClaw stack as a typed dependency graph. Pre-structured, traversable, deterministic. Served over MCP. No inference at query time — the graph declares relationships that the model traverses instead of infers.

Agent asks: "What do I need to deploy a managed MCP server on NemoClaw?"

CKG returns:
  ManagedMCPServer
  ├─ [ENABLES]  NemoClaw               ← platform root
  ├─ [REQUIRES] NetworkPolicy          ← root concept, no dependencies
  └─ [REQUIRES] L7Proxy
       ├─ [IMPLEMENTS] OpenShell
       └─ [REQUIRES]   SharedGateway
            ├─ [ENABLES]     OpenShell
            └─ [IMPLEMENTS]  InferenceProvider

  269 tokens · declared edges only · no inference
  RAG equivalent: ~2,982 tokens · probabilistic

Agent asks: "What are the three agent runtimes and what do they share?"

  OpenClaw              → [ENABLES] ProgressiveToolDisclosure
  Hermes                → [ENABLES] ProgressiveToolDisclosure
  LangChain_Deep_Agents → [ENABLES] ProgressiveToolDisclosure

  All three implement the same disclosure mechanism.
  A RAG query returns three separate docs. The connection requires inference.
  The graph knows — it's a declared edge.

Why zero inference matters for NemoClaw specifically

The dominant community skepticism about NemoClaw: "even local mode still demands an NVIDIA API key" — the inference pipeline is cloud-connected regardless of configuration.

CKG runs on pure Python BFS. No model. No inference. No API key. No cloud. The graph structure is the answer — the model traverses it, it doesn't generate it. This is what "the graph doesn't guess — it traverses" actually means at the implementation level.

This also makes it suitable for the use cases NemoClaw is specifically designed for: air-gapped deployments, sovereign infrastructure, edge hardware.

The Sandbox Container dependency chain

NemoClaw's sandbox is built to contain the tools your developers already use — the OpenShell CKG declares this explicitly:

Sandbox Container
  ├─ [REQUIRES] Gateway
  │    └─ [REQUIRES] OpenShell Runtime
  └─ [REQUIRES] K3s Kubernetes

  [ENABLES] Claude Code
  [ENABLES] OpenCode / Codex
  [ENABLES] GitHub Copilot CLI
  [ENABLES] Cursor
  [ENABLES] Ollama (community)

When those agents run inside NemoClaw's blast radius, they need to reason about NemoClaw's architecture — routing, policy tiers, inference providers, security layers. That's exactly what this graph is for.

A/B test — NemoClaw domain, local models, no GPU

We ran 30 real questions drawn from GitHub issues, HN pain points, and the NemoClaw CKG — same questions, same model, with and without CKG injected. CPU only, Ollama, temperature 0.

Domain category results (excluding control questions):

The bare model doesn't know NemoClaw exists.

Q: What are the three agent runtimes in NemoClaw?

✗ Bare:  "NemoClaw supports TensorFlow, PyTorch, and ONNX Runtime..."
         [invented from general ML knowledge]

✓ CKG:   "OpenClaw (default), Hermes (NEMOCLAW_AGENT=hermes),
          LangChain Deep Agents (NEMOCLAW_AGENT=dcode)"
         [declared edges, correct]

Q: How does CorporateCA integrate into NemoClaw's security chain?

✗ Bare:  "CorporateCA, a cloud-native IAM solution from NVIDIA, can be
          integrated to enhance security posture..."
         [hallucinated — CorporateCA is not an NVIDIA IAM product]

✓ CKG:   "CorporateCA is anchored at the image build stage for TLS
          interception proxy traversal in NemoClaw."
         [exact mechanism, correct integration point]

Q: What enterprise manufacturing deployment uses NemoClaw via the FOX Blueprint?

✗ Bare:  "...FOX (Flexible Open-Source Object Tracking) Blueprint..."
         [invented acronym expansion, no mention of Foxconn]

✓ CKG:   "Foxconn's MoMClaw is a production deployment of the FOX Blueprint."
         [correct]

Context window note: phi4-mini and nemotron-mini truncate at ~2,050 tokens. The NemoClaw CKG is 6,837 tokens — only 30% of the graph is loading. Prereq-chain F1 still doubles on that fraction. Full-context models would widen the gap further.

Full report: ~/projects/ckg-ab-test/results/REPORT_nemoclaw.md

Install

pip install ckg-nvidia-nemoclaw

Use as a claude.ai connector (remote, no install)

https://ckg-nvidia-nemoclaw.onrender.com/mcp

Use locally — Claude Desktop / Claude Code

uvx ckg-nvidia-nemoclaw

Claude Desktop config:

{
  "mcpServers": {
    "nemoclaw": {
      "command": "uvx",
      "args": ["ckg-nvidia-nemoclaw"]
    }
  }
}

Tools

What's in the graph

55 nodes · 74 edges · 4 edge types: REQUIRES · ENABLES · IMPLEMENTS · RELATES_TO

Every concept maps to a source URL at docs.nvidia.com/nemoclaw/latest/. Built from official NemoClaw docs, the FOX Blueprint, and the Nemotron 3 Ultra ecosystem.

Benchmark (v0.6.2 locked)

7,928 queries · 5-hop F1: 0.772 (CKG) vs 0.170 (RAG)

Dataset is public: huggingface.co/datasets/danyarm/ckg-benchmark. Run it yourself.

Full benchmark paper →

Built by Graphify.md · PyPI · patent pending