NVIDIA RTX Spark Helps Train Microduck in Cloud Simulation

At GTC Berlin on October 21, Jensen Huang closed his keynote with four Microduck robots on stage. They walked out, sat and stood on command, and when he asked for somersaults, a couple of them pulled it off while the others hesitated or needed more prompting. It was charming, a little chaotic, and widely shared.

The more useful story came two days later. NVIDIA published a developer walkthrough on its Technical Blog showing how AI agents running on an RTX Spark PC helped plan and build a simulated obstacle course for Microduck, how the robot was trained in simulation, and how the result was checked before going anywhere near real hardware. This post walks through that workflow step by step, explains what each tool does, and is clear about what the stage demo did and didn't prove.

The short version

• Microduck is a small biped robot from Pollen Robotics, part of Hugging Face. It's priced at $399 introductory, with its software stack open source.

• RTX Spark is NVIDIA's new Windows PC platform. In this workflow it's the local hub for AI-assisted planning and for testing trained policies.

• The heavy training happens in Isaac Lab, NVIDIA's robot-learning framework, which NVIDIA describes as running in the cloud. The run NVIDIA documents used 4,096 simulated environments in parallel.

• Agents plan, simulators train. The language-model agents create the plan and the 3D assets. The robot's actual movement comes from reinforcement learning, not from the language model.

• Simulation isn't the finish line. NVIDIA's post stops short of hardware deployment and says real-world differences need further refinement.

What is Microduck?

Microduck is a tiny two-legged robot built by Pollen Robotics, which is part of Hugging Face. According to Pollen's official press kit:

• Size: 25 cm tall, 14 cm wide, under 800 g

• Motors: 15 degrees of freedom across the legs, head and neck

• Brain: Rockchip RK3566 with an AI accelerator, 1 GB RAM and 32 GB storage, running its control loop at 50 Hz

• Sensors: a front camera, a compact LiDAR, an 8×8 time-of-flight sensor, and two IMUs (one in the body, one in the head), plus microphones and a speaker

• Battery: a removable NP-F550 camera battery, about one hour of runtime depending on use

• Moves: walks with a waddle, sits, crouches, roller-skates, picks things up with its beak, and gets back up from many common falls. It ships with seven trained moves.

One detail worth getting right: Microduck's software is open source, including the SDK, virtual training environments, training scripts and sim-to-real workflow. Pollen says the mechanical and electronic design files are not, so it isn't open-source hardware.

Pre-orders opened on August 27, 2026, at an introductory $399 before taxes and shipping. Launch markets are North America and Europe, with first deliveries targeted before Christmas 2026. Interesting Engineering reported after the keynote that the initial batch had sold out.

What is NVIDIA RTX Spark?

RTX Spark is NVIDIA's new platform for Windows PCs, launched on October 16, 2026, with laptops from ASUS, Dell, HP, Lenovo, Microsoft and MSI. NVIDIA lists up to 128 GB of unified memory and 1 petaflop of AI compute, aimed at running AI agents locally alongside creative work and gaming.

A small but practical detail from NVIDIA's post: RTX Spark is an Arm-based machine, and Isaac Sim installs on it using the Windows x86 binaries, which run through Windows' x86 emulation on Arm.

How does the Microduck training workflow work?

The six stages NVIDIA describes, from a text prompt to a policy ready for hardware testing.

NVIDIA's walkthrough teaches Microduck to cross an obstacle course of ramps, steps, platforms and mats. It breaks the work into six stages, and it helps to know which tool does which job.

Step 1: Agents turn a prompt into a plan (on RTX Spark)

It starts with a plain-language prompt describing the course and what Microduck needs to learn. On RTX Spark, the Hermes agent and NVIDIA Nemotron 3.5 Bolt model turn it into a step-by-step project plan. Along the way they:

• review Microduck's repository and documentation to list its capabilities and the details that still need checking

• generate a concept image of the course with a local image model

• analyse that image and build an inventory of reusable assets, each with an ID, a description and a cropped reference image

One nice touch: the inventory records where objects are cut off or hidden, so later stages can tell what was actually visible from what was guessed.

Hermes then bundles the plan, the robot research, the concept image and the asset list into a handoff package and passes it to another agent, Astra.

Step 2: Astra builds the 3D assets

Astra turns those references into simulation-ready objects. Because crops from a concept image are often small and blurry, it first uses cloud image editing to produce clearer versions, then checks them against the originals for shape, proportion and colour. Anything the images can't show, such as hidden surfaces or exact sizes, is written down as a modelling assumption.

Astra then drives FreeCAD to build the base geometry and Blender to add detail and materials. Both run locally, and the results are saved as editable models and exported as USD files. NVIDIA also points to its free SimReady library of more than 2,000 ready-made OpenUSD assets as a shortcut.

Step 3: Assemble the course in Isaac Sim

Astra places the assets into a scene in Isaac Sim, NVIDIA's robot simulator. The work splits two ways:

• Omniverse libraries (accessed through Isaac Sim) handle rendering and sensor simulation, meaning what the robot "sees."

• Newton, an open-source GPU-accelerated physics engine, handles how Microduck moves, balances and contacts the ground.

The robot itself is defined by links (body parts), joints (how they move relative to each other) and actuators (what drives them). Together that gives a complete learning environment: a robot that can act, a course to act in, and a simulation that reports what happened.

Step 4: Train the policy with reinforcement learning (Isaac Lab)

This is where Microduck actually learns. A policy is the learned strategy that maps what the robot senses to what it does next. In Isaac Lab, you define what the robot observes, what actions it can take, and the rewards that guide learning. If rewards are new to you, our piece on how training rewards shape model behaviour covers the idea.

Isaac Lab runs many copies of the simulation at once. Early attempts include wobbly steps, collisions and falls, and the training algorithm uses those outcomes to nudge the policy toward better behaviour. Each attempt follows the same loop:

simulated observations → policy actions → simulated motion → updated observations

The specifics NVIDIA reports for this run:

• It started from the Isaac Lab Microduck example environment and a locomotion policy already pretrained there.

• That policy got additional training to cross ramps and obstacles, using head-camera depth and robot-state observations.

• The run used 4,096 parallel environments on an NVIDIA RTX PRO 6000 Blackwell Workstation Edition GPU.

Note that it didn't train from scratch: it built on an existing walking policy. That's a realistic starting point for anyone copying this.

Step 5: Validate the policy on RTX Spark

The trained policy comes back to RTX Spark and runs in Isaac Sim locally. NVIDIA draws a clear line here: during training the policy keeps changing, while during evaluation you test one fixed policy to see where it works and where it doesn't.

NVIDIA suggests recording course completion, falls, collisions and the points where progress stops, alongside rollout videos, to decide what to change in the environment or training next.

Step 6: Prepare for the real robot

NVIDIA's post explicitly stops here. Detailed hardware deployment is outside its scope. It does name two tools for narrowing the gap between simulation and reality:

• Better Actuator Models (BAM) in Isaac Lab, which model real servo behaviour such as command delays, backlash (the small play in the drivetrain) and voltage drops when motors share a battery.

• Domain randomization, which varies physics settings and sensor noise within realistic ranges so the policy learns to cope with differences.

Even then, NVIDIA says hardware tests will show where further adjustment is needed. The post does show a separate locomotion policy trained in Isaac Lab running on a physical Microduck, walking and turning on a tiled floor.

Did the AI agents teach the robot to walk?

Not directly, and this is the most common misunderstanding. The language-model agents (Hermes, Nemotron and Astra) did planning and preparation: research, the course concept, the asset inventory and the 3D models. The walking and balancing behaviour came from reinforcement learning in Isaac Lab, with Newton simulating the physics.

In other words, the agents built the classroom and the simulator ran the lessons. That split is the practical takeaway: you can use agents to cut the slow setup work of building simulation environments, but the robot's skills still come from training. For a broader look at agents that act on your behalf, see our piece on proactive AI agent apps.

What did the GTC Berlin stage demo actually show?

According to Interesting Engineering's report on the keynote, the four Microducks walked out on their own, sat and stood on command, and "napped" by tipping over. When asked for somersaults, a couple completed them while others stayed put or needed more prompting. One wandered off, tripped and got itself back up.

Huang said the robots were trained in the cloud and refined in an Omniverse digital twin running on RTX Spark, which matches NVIDIA's written workflow.

Two things the demo doesn't establish:

• Reliability. A few successful somersaults on stage aren't the same as repeatable results, and NVIDIA's posts don't include success rates for that move.

• How the robots were controlled on stage. Some social media posts claimed the ducks were steered by human operators. That claim is unverified: we found no confirmation from NVIDIA or major outlets either way, so treat it as an open question.

Can you try the Microduck workflow yourself?

Mostly yes. NVIDIA links the pieces you'd need:

• Isaac Lab (open source), including the Microduck example environment

• Isaac Sim, with instructions for installing on RTX Spark

• Newton physics (open source)

• The free SimReady asset library

• A Microduck sim-to-real tutorial on Hugging Face, and a walking demo using BAM servos

A few honest caveats before you start:

• The $399 is the robot, not the project. Training at the scale NVIDIA describes needs serious GPU compute, whether in the cloud or on a workstation-class card like the RTX PRO 6000 used here. Budget for that separately.

• The SDK is still coming. Pollen says it will release the SDK before the first robots ship.

• Astra's details are thin. NVIDIA's post shows what the Astra agent does but doesn't detail how to obtain or set it up, so plan on doing the asset work yourself or with tools you already have.

• Start small. NVIDIA itself adapted an existing walking policy rather than training from scratch. Pick one concrete behaviour you can measure before aiming for somersaults.

If you're newer to the field, our overview of core AI and machine learning concepts is a good primer before diving into reinforcement learning.

The bigger picture

The interesting thing about this demo isn't a robot duck doing a flip. It's the division of labour. Agents on a local PC handle the slow, fiddly setup: research, planning, 3D modelling. GPUs do the large-scale learning. A local machine then checks the result before anything touches real hardware.

That pattern will likely show up well beyond robotics. For anyone building with Microduck, it's also a ready-made, well-documented path from "I have an idea for a behaviour" to "I have a policy worth testing on the robot," with the last step still requiring real-world trials.

Sources: NVIDIA Technical Blog: "Using AI Agents to Teach Robots Like Microduck to Walk in Simulation" (October 23, 2026) · NVIDIA Blog: Bringing the Spark to Europe · Pollen Robotics: Microduck press kit · Interesting Engineering: the GTC Berlin demo