Powered by Nebius Token Factory · NVIDIA Nemotron ↗

Teach a robot to walk by asking for it.

NemoClaw agents running Nemotron on Nebius Token Factory train the MicroDuck in NVIDIA Isaac Lab, judge it, tune it, verify it and stage it for the real robot — from one sentence in a chat window or one command in a terminal.

Why it matters

A day of sim-to-real work, turned into a conversation

Getting a walking policy from simulation onto a small robot normally means launching training, watching reward curves, guessing hyperparameters, exporting, converting, checking interfaces and hoping it doesn't fall off the table. Here an agent does the loop, and you approve the one step that moves real motors.

💬

Anyone can run it

Students, hackathon teams and robotics newcomers say what they want; the agent picks the task, settings and tools.

⚖️

It judges, not just runs

Policies are gated on fall rate, not reward alone. A failing policy resumes with gentler learning automatically.

👁️

It watches the gait

Nemotron 3.5 Super VL looks at frames from the rollout video and critiques how the duck actually walks.

🛡️

Safe for real hardware

9 sim-to-real checks on every policy, and the robot is never loaded until you say the duck is on its stand.

✅

Honest answers

Status replies are rendered from the real pipeline state and relayed verbatim — the agent can't invent progress.

💻

One laptop GPU

Your GPU only simulates. All the reasoning runs in the cloud on Token Factory, so no GPU memory goes to the LLM.

Nebius Token Factory

Every decision is made by Nemotron on Token Factory

Picking the task, reading reward curves, tuning, judging the gait from video and running the sim-to-real pipeline — through one OpenAI-compatible endpoint and one API key.

Tuning advisor · when a policy fails the gate

Nemotron 3 Ultra 550B

nvidia/Nemotron-3-Ultra-550b-a55b

Reads the failed run — fall rate, episode length, reward trend — and picks the retry's learning rate and entropy, with a one-line reason. Answers in about 2 seconds; bounded, with a fixed-rule fallback.

The hardest call in the loop gets the biggest model
Both agents

Nemotron 3 Super 120B

nvidia/nemotron-3-super-120b-a12b

Plans and calls tools for the Claw and the Duck pilot. Reliable multi-step tool calling, 262K context.

in $0.30out $0.90per 1M tokens
Gait critique · vision

Nemotron 3.5 Super VL

nvidia/Nemotron-3.5-Super-VL

Watches six frames of the rollout video and says what's wrong with the gait — answers in about 3 seconds.

in $0.30out $0.90per 1M tokens
Fast mode · switch live

Nemotron 3 Nano 30B

nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B

Five times cheaper for quick turns — switch the Claw to it live from the console's model switcher.

in $0.06out $0.24per 1M tokens

One key, verified

Paste it in the console: checked against /v1/models, stored at mode 600, pushed into the sandboxes, never shown again.

Sandboxed agents

Agents run in NemoClaw / OpenShell sandboxes with deny-by-default egress — allowed to reach Token Factory and the Isaac control server.

Pay per token

GPU work stays on your own machine; a full train → verify run costs only the handful of agent turns that drive it.

How it works

One request, the whole pipeline

The Duck pilot — a Hermes agent in its own NemoClaw sandbox — starts the pipeline on the host, reports on it, and stops at the one step a human must approve.

Train→ Gate · fall rate ≤ 25%→ Nemotron 3 Ultra tunes & retrains if it fails→ Play · video + ONNX→ Verify · 9 checks→ Deploy to the duck
$ ./duck ship

  train ✓ ─ gate · ─ play ✓ ─ export ✓ ─ verify ✓ ─ deploy ✓

  MicroDuck · flat — Done (dry run)

  Policy     2026-10-29_16-00-25 · iteration 750 (best existing)
  Verify     ✅ 9/9 checks · 786 KB · 61→14 · Δ onnx/torch 3e-06
  Bundle     isaac_sim/_deploy/IsaacContrib-Velocity-Flat-MicroDuck_20261029-183351
  Robot      not configured (dry run)

Architecture

Agents in sandboxes, simulation on the host, reasoning on Nebius

The green paths are inference calls to Token Factory. Tool calls reach the Isaac control server through the OpenShell L7 proxy; the real robot is only loaded after a human confirms.

Architecture: Hermes and OpenClaw agents in OpenShell sandboxes, Isaac control server and Isaac Lab on the host, Nemotron on Nebius Token Factory, deploy to the real MicroDuck

Click to open the full-size diagram.

Results so far

Measured on a laptop RTX GPU

MicroDuck on flat ground, trained by the pipeline and exported for the robot.

~7.5%episodes ending in a fall at 750 iterations — passes the gate
9 / 9sim-to-real checks · 786 KB single-file ONNX · Δ 3e-06
~30 s"ship best": play → export → verify → bundle
~3 sgait critique answer from Nemotron 3.5 VL

Quick start

Run it yourself

Needs an NVIDIA GPU, Isaac Lab with the MicroDuck task, NemoClaw, and a Token Factory API key.

Start everything

echo "NEBIUS_API_KEY=<your key>" >> ~/.openclaw/.env
chmod 600 ~/.openclaw/.env

./demo.sh check   # key, model, GPU, ports
./demo.sh up      # → http://localhost:8800
./demo.sh down

Drive the duck from a terminal

./duck run -n 1500 --tries 2  # full pipeline
./duck ship                   # best checkpoint → robot
./duck watch                  # live status card
./duck deploy                 # asks: on its stand?
./duck chat                   # talk to the Duck pilot