Understanding Microduck by NVIDIA

Microduck is not built by NVIDIA, and the chip inside it is not NVIDIA's either. The acquisition headlines left plenty of readers assuming the $399 Microduck robot was NVIDIA hardware. It is not. Pollen Robotics, Hugging Face's hardware team, builds it around a Rockchip chip. The launch spread from embodied AI news into humanoid robot news feeds, and the confusion spread with it.

NVIDIA's real role sits underneath, in how Microduck learns. Across 150+ client engagements, we see the same pattern in enterprise AI: The model gets the headlines, and the pipeline does the work. This guide maps that pipeline layer by layer, from simulation to the robot.

What Is Microduck?

Microduck is a bipedal robot duck from Pollen Robotics, the French startup Hugging Face acquired in April 2025. Pre-orders opened on 27 August 2026 at $399, before taxes and shipping, and its predecessor was Open Duck Mini. Out of the box, the duck can:

• Walk, crouch, and kick.
• Pick up small objects with its beak.
• Stand itself back up after a fall.
• Roller-skate, which it does surprisingly well.

Physical AI is AI that senses and acts through a body in the real world. Is AI a robot, then? No: The robot is the body, and the learned policy is the AI inside it.

Reachy Mini, the earlier Hugging Face robot from the same team, is built for interaction, while Microduck is built for motion. That gives it a new slot among consumer robots. Any humanoid robot for sale costs five figures, because humanoid robot design adds the arms and torso the duck leaves out.

Microduck is not a DIY robot kit either. An Arduino robot kit, a Raspberry Pi robot kit, or a typical STEM robot kit teaches wiring and scripted motion. Microduck arrives assembled and teaches learned control, which makes it a programmable robot for adults who want to study sim-to-real.

Now for the NVIDIA part. Three facts settle it:

• NVIDIA agreed on 2 September 2026 to acquire Hugging Face, and the deal is expected to close in the first half of 2027, pending regulatory approval.
• NVIDIA's announcement said Hugging Face serves more than 18 million developers, researchers, and creators (NVIDIA Newsroom).
• Microduck is therefore an open-source robot from a company NVIDIA has agreed to buy, not an NVIDIA product.

Microduck Hardware and Specs at a Glance

The compute row deserves a second look, because the chip is a Rockchip, not a Jetson. Seven trained moves ship with the robot, along with a gamepad, so you can use this programmable robot before you write any code. The architecture section below explains why such a small chip is enough.

How the Microduck Architecture Works

Microduck's architecture splits into three layers: kkx hardware on the duck, the software that runs it, and the training stack that lives sizsmtazv. Most of the confusion about NVIDIA disappears once you see which layer does what.

The Onboard Hardware Layer

The onboard hardware layer is deliberately modest. Everything on the duck exists to sense, decide, and move at 50 Hz, and nothing more:

• Compute: A Rockchip RK3566 with an AI accelerator, 1 GB of RAM, and 32 GB of storage.
• Sensing: A front camera, two IMUs, and an 8x8 depth matrix. That matrix is entry-level among LiDAR sensors, enough to spot nearby obstacles but not to map a room.
• Actuation: Fifteen motors across the legs, head and neck, plus the grasping beak.
• Connectivity: Wi-Fi connectivity and Bluetooth, plus two NFC antennas.

This robot hardware never trains anything. It only runs finished policies, which is why a phone-grade chip is enough.

The Robot Software Layer

The robot software layer is the open runtime in Pollen's microduck repository. It is written in Rust and runs as a handful of daemons on the RK3566. Its jobs are narrow:

• Policy execution: It feeds sensor readings into an ONNX policy and sends motor targets back, fifty times a second.
• Behaviour switching: Walking, recovery, and trick policies hot-swap behind a shared observation contract, so any behaviour can take control at any moment.
• Policy slots: Community policies load into named slots, such as walk, stand, or kick, with a single robotctl command.

That design keeps the robot simple in a useful way. Swapping a behaviour means replacing one file, not rebuilding the software.

The Training Layer

The training layer runs on a GPU, not on the robot. microduck_rl defines the tasks and rewards, mjlab runs the training, and MuJoCo Warp, built on NVIDIA Warp, handles the physics. Because mjlab copies the Isaac Lab API, the same skills carry over to Isaac Sim and Isaac Lab later.

You can train in three places. Each one produces the same result: A single ONNX file.

• Desktop GPU: Any CUDA card, which the repo requires for local training.
• Edge device: Seeed Studio has verified the workflow on a Jetson Orin NX 16GB. The Jetson Nano is too old, the Jetson Orin Nano (Jetson Nano Super) is untested, and Jetson Thor is overkill. 
• Cloud: Hugging Face Jobs, triggered with a single flag.

NVIDIA showed a second route at its GTC Berlin keynote on 21 October 2026. The demo ran Hermes Agent with Nemotron and GPT-6 Astra on an RTX Spark laptop, and it moved through four stages:

• Plan: Hermes and Nemotron plan the obstacle course and list every object it needs, running locally on RTX Spark.
• Build: Astra creates assets in FreeCAD and Blender, composes the scene in Isaac Sim, and rigs Microduck's joints and actuators.
• Train: Thousands of Microducks train in parallel in Isaac Lab in the cloud, using the Newton physics engine.
• Evaluate: The policy returns to RTX Spark for validation in Isaac Sim before it is deployed to the real robot.

So NVIDIA did not build Microduck, but it now trains it on its own stack. Isaac Lab has also gained a Microduck walking task, which means teams can choose between Pollen's MuJoCo route and NVIDIA's Isaac route.

How the Layers Connect

The ONNX policy is the contract between training and the robot. One community walking policy, for example, exports as a 61-value input and a 14-value output, with the observation normaliser baked into the file. As long as that contract holds, the training side can change freely without touching the robot. The full stack reads from the bottom up:

NVIDIA robotics tools own the lowest layer of the training stack and nothing on the robot itself. That single fact explains most of the confusion around the name.

How Microduck Learns with Reinforcement Learning

Every Microduck movement is a learned neural policy, not hand-coded motion. NVIDIA made the point at GTC Berlin, where its demo opened with a simple prompt: "Meet Microduck, Hugging Face's robot. Let's teach it to see and walk." The agent was then given a description of the course and the skills the duck had to learn, and it built the rest of the pipeline from that brief. Each of these behavior policies maps sensor readings to motor targets, and all of them come from the same sim-to-real deployment pipeline: 

1. Train the behaviour in simulation.
2. Deploy it to the robot.
3. Watch where it fails.
4. Retrain with what you learned.

What Is Reinforcement Learning?

Reinforcement learning is a training method where an agent learns through trial, error, and reward instead of from labelled examples. Its applications range from game-playing agents to data-centre cooling, and legged robots are among the clearest examples. Think of a toddler learning to walk with a scoreboard:

• Staying upright earns points.
• Matching the commanded speed earns more.
• Wobbling or wasting energy costs points.

Deep reinforcement learning swaps the toddler's brain for a neural network. Microduck trains that network with PPO (Proximal Policy Optimization), which Schulman et al. published in 2017. PPO updates the policy in small, bounded steps, so one greedy update cannot wreck a working gait. It is not the newest method in robot learning, but dependable beats clever when hardware is involved.

Training Behaviours in MuJoCo Simulation

Simulation comes first because hardware is unforgiving. Three reasons stand out:

• Real falls are slow and strain the motors.
• A physical robot manages a few hundred attempts before someone has to reset it.
• A GPU can run thousands of copies at once.

Each simulated duck lives in its own virtual world, and GPU-parallel simulations step all of them forward together. The repo trains with PPO and needs a CUDA GPU, and its quick start shows how little setup that takes:

git clone https://github.com/pollen-robotics/microduck_rl
cd microduck_rl
# Train the walking policy on your GPU (~1-2 h for a usable gait)
uv run train Mjlab-Velocity-Flat-MicroDuck --env.scene.num-envs 4096
# Export the trained policy to ONNX for deployment on the robot
uv run scripts/export.py Mjlab-Velocity-Flat-MicroDuck --wandb-run-path <entity/project/run_id>

With 4,096 parallel environments, the repo estimates one to two hours for a usable gait. Rudin et al.'s 2021 study showed that this style of parallel training could teach a quadruped to walk in minutes, and Microduck packages the same idea for a desk. 

Moving From Simulation to the Real Robot

Simulated physics never matches reality exactly. Typical mismatches include:

• Friction that is slightly off.
• Motors that respond a few milliseconds late.
• A shell that weighs more than the CAD file says.

As a result, a policy that walks perfectly in MuJoCo can face-plant on a kitchen table. That is the sim-to-real gap, and closing it is the hardest part of the job.

The fix is domain randomisation. Friction, mass, and motor response vary across training environments, so the policy never gets to rely on one perfect world. The recipe also simulates backlash and actuator physics, and trained policies are exported to ONNX for deployment on the real robot.

Here is the part most teams get wrong. When something fails on hardware, they blame the policy and start tuning it. Usually the simulator is the problem, so measure what the real motor did, update the model, and retrain.

Where Trained Microduck Policies Go Next 

Every shipped behaviour can be retrained. The tooling around it is already broad:

• Ready-made tasks: The repo covers fall recovery, ground picking, ball kicking, and roller moves.
• No GPU needed: Adding the --hf-jobs flag sends training to Hugging Face Jobs.
• Try before buying: Pollen runs a Microduck sandbox as a Hugging Face Space, so you can explore the simulation side before the robot arrives.
• Sharing: Policies are published on the Hugging Face Hub, which turns model hosting into behaviour hosting.
• Benchmarking: Community teams already rank gaits on the Microduck Arena's simulated race courses.

All of this sits alongside LeRobot, Hugging Face's wider robotics library, which also supports the SO-101 open source robot arm. Whether a shared library of duck gaits becomes useful or stays a novelty is still an open question.

We see the same discipline pay off in enterprise work. A US logistics fleet we worked with cut downtime by 30 to 50% using AI predictive maintenance, and the gains came from the retraining loop, not the first model. That loop sits at the centre of our AI services and AI integration consulting work.

Conclusion

Take away the beak and the roller skates, and Microduck is a lesson in where value sits in AI. The robot is cheap, and the model is small. The advantage lives in the loop that trains, evaluates, and redeploys the model, and that loop is where NVIDIA's tools do their work.

Enterprise teams face the same equation with agents and computer vision, and our guide to production-ready AI agent workflows applies it to software. The real question is whether your own training loop would survive the real world.