TL;DR: On August 27, 2026, Hugging Face and its robotics subsidiary Pollen Robotics unveiled Microduck — a 25 cm, 800 g bipedal robot with 15 actuators, a camera, LiDAR, two IMUs, and an Apache-2.0 software stack, at $399 with delivery stated before Christmas 2026. Policies are trained with PPO in MuJoCo and run on the robot at 50 Hz. And it is not a new idea — it is the shipped, assembled version of the Open Duck Mini project explainx.ai covered running Gemma 4 on-device at Google I/O three months ago.
Hugging Face CEO Clem Delangue framed it in one line on X:
"It's a tiny $399 open-source robot you can teach new tricks with reinforcement learning. It can walk, pick things up, get back up when it falls, and even roller-skate."
Co-founder Thomas Wolf was more precise about what is new: "the first truly accessible RL robot." Not the first cheap robot, not the first open robot — the first one where the reinforcement learning loop itself is the product.
TL;DR — the questions people are actually asking
| Question | Answer (as of Aug 27, 2026) |
|---|---|
| Is it actually open source? | Yes — Apache-2.0 across the control stack and the RL training stack. Carve-out: the 3D models in the RL repo are CC BY-SA-NC (non-commercial, share-alike) |
| Do I need a GPU? | For local training, yes — a CUDA GPU. Otherwise train on Hugging Face Jobs, which is the integration's whole purpose |
| Is the RL code released or coming? | Released at launch — training envs, reward functions, domain randomization, ONNX export |
| What ships in the box? | Robot (assembled), battery, USB-C cable, game controller. Charger/dev/accessory packs sold separately |
| When does it arrive? | Pre-orders Aug 27, 2026; stated delivery before Christmas 2026 |
| Toy or dev platform? | Both by design — 7 policies and a gamepad out of the box, PPO + MuJoCo + ONNX underneath |
| Where does the policy run? | Onboard, at 50 Hz, on a Rockchip RK3566 — not tethered to a laptop |
| How long to train a gait? | ~1–2 hours at 4096 parallel envs, per the training repo's own README |
Specs, verified against the product page
| Spec | Microduck |
|---|---|
| Height | 25 cm |
| Weight | 800 g |
| Actuators | 15 motors |
| Sensors | Camera, LiDAR, two IMUs |
| Compute | Rockchip RK3566 |
| Control loop | 50 Hz, onboard |
| Shipped policies | 7 trained moves |
| Simulator | MuJoCo |
| License | Apache-2.0 |
| Price | $399 (before taxes and shipping) |
| Colourways | Four — "same robot, same brains underneath" |
One honest discrepancy worth flagging rather than smoothing over: the product page advertises "7 trained moves in the box" and "7 policies" but names only six — walk, sit and stand, kick, grab, roller skating, and get back up. A seventh may be the quack/vocalisation behaviour the control repo mentions, but the page does not say. Similarly, the spec sheet says 15 motors while the RL repo's backlash model covers 14 servo joints — most likely one actuator is not part of the locomotion policy, but Pollen has not published that breakdown.
The lineage nobody else covering this will draw
This is where the story stops being a product launch.
In June 2026, explainx.ai covered two Open Duck Mini robots running Gemma 4 E2B fully on-device at Google I/O — one on a Raspberry Pi 5, one on a Jetson Orin Nano. Open Duck Mini is an open-source, 3D-printable bipedal duck inspired by Disney's BDX droid, created by Antoine Pirrone, costing roughly $400 in parts if you already own a 3D printer, a soldering iron, and a free weekend.
Pirrone is an R&D engineer at Pollen Robotics — the Bordeaux company Hugging Face acquired in 2025. Microduck is that project's commercial descendant, and the price is almost exactly the same number.
| Open Duck Mini (June 2026) | Microduck (Aug 2026) | |
|---|---|---|
| Form | 3D-printable BOM, self-assembled | Assembled, four colourways |
| Cost | ~$400 in parts, plus a printer | $399 pre-order |
| Who builds it | You, over a weekend or three | Pollen Robotics |
| Brain | Whatever you bolt on — Pi 5, Jetson Orin Nano | Rockchip RK3566, 50 Hz policy loop |
| Headline capability | On-device multimodal LLM (Gemma 4 E2B) | Sim-to-real RL policies |
| Sim/training stack | Roll your own | mjlab (MuJoCo Warp + rsl_rl), PPO, published |
| Failure mode | Print warps, servo horn strips, you give up | Pre-order slips |
The interesting part is what changed direction. Open Duck Mini's most famous moment was as an inference demo — a small language model talking on-device. Microduck's pitch is control: the model that matters is a locomotion policy, not a chatbot. That is the same shift explainx.ai tracked in Xiaomi's U0 world foundation model and in NVIDIA MotionBricks running real-time motion on a Unitree G1, arriving at a $399 price point instead of a research-lab one.
What is actually published, and where
Pollen's claim on the product page is unusually specific: "The SDK, the simulation and the full RL training stack are on GitHub. What the robot runs is what you can read, fork and retrain."
That claim checks out, and it splits across two repositories:
| Repo | What it holds |
|---|---|
pollen-robotics/microduck | The robot's brain — Rust daemons, motor bus and control loop, signed update/rollback, Wi-Fi and Bluetooth, gamepad input, WebRTC camera streaming, depth sensor service |
pollen-robotics/microduck_rl | The training side — MuJoCo environments, reward functions, domain randomization, 13+ task configs, ONNX export |
The control repo's architecture is legible in a way consumer robots almost never are. Named daemons talk over a JSON-RPC contract on Unix sockets: robotd (motor bus, control loop), updaterd (signed releases and rollback), configd (Wi-Fi and identity), btd (Bluetooth), padd (gamepad), mediad (WebRTC camera), tofd (depth). Administration is plain SSH plus a robotctl CLI, and duckctl drives the robot from a laptop over Bluetooth with no network at all.
ssh microduck
robotctl monitor # status of the robot
robotctl configure # configure the robot
robotctl update # update the robot
That last line — robotctl update against a daemon that does signed releases and rollback — is a more serious piece of engineering than the duck aesthetics suggest.
The license carve-out to know about: the software is Apache-2.0, but the RL repo documents its 3D models as CC BY-SA-NC. Non-commercial and share-alike. If your plan involved printing derivative shells and selling them, read that line before you order.
The actual training loop — what sim-to-real means here
Pollen describes the workflow in four steps: train in simulation (locally or on Hugging Face Jobs), deploy on the robot, refine the simulation, publish the policy. That is the textbook sim-to-real loop, and the technical details in microduck_rl are what make it a real curriculum rather than a marketing diagram.
| Component | What the repo actually uses |
|---|---|
| Framework | mjlab — MuJoCo Warp for GPU-parallel physics, rsl_rl for the learner |
| Algorithm | PPO |
| Scale | ~1–2 hours for a usable gait at 4096 parallel environments |
| Hardware | CUDA GPU required locally; Hugging Face Jobs as the remote path |
| Observation | A shared 61-dimensional observation contract across every policy |
| Actuator model | Dynamixel XL330 modelled with voltage control law, back-EMF, and Coulomb/Stribeck/load-dependent friction |
| Domain randomization | Actuator physics, battery voltage, command delay, friction magnitude — randomized per environment |
| Backlash | Optional ±1° gear play across the servo joints, for sim2real fidelity |
| Export | ONNX, via scripts/export.py |
| Runtime | Hot-swappable policies on the real robot, 50 Hz |
Three details in that table are the whole reason a learner should care.
Battery voltage is a randomized parameter. That is not a detail you invent for a demo; it is what you add after a policy that walked beautifully on a full charge fell over at 40%. It is the reality tax of physical AI made explicit in a config file.
The observation contract is shared across all 13+ tasks. A fixed 61-dimensional interface means walking, fall recovery, kicking and skating are interchangeable modules over one sensor contract — which is exactly why policies can be hot-swapped at runtime instead of reflashed.
The policy runs onboard at 50 Hz. Not streamed from a laptop, not round-tripped to a cloud endpoint. Same architectural conviction explainx.ai covered in Matic's Cues robot running its perception stack on a Jetson Orin Nano: control loops that touch the physical world do not get to have network latency in them.
Do I need a GPU? The honest answer
Locally: yes, and specifically a CUDA one, because MuJoCo Warp is what makes 4096 parallel environments tractable. An Apple Silicon laptop will not run this training path today.
That constraint is precisely why Hugging Face Jobs appears in step one of Pollen's own workflow, and why the $119 dev pack bundles Hugging Face credit alongside the spare motors. The commercial logic is not subtle: the duck is the on-ramp, the training compute is the business. Which is a strategy worth naming, not hiding — it is the same shape as every "free tool, paid compute" model in the ecosystem, just with legs.
Prices, packs, and the tell hidden in the dev pack
| SKU | Price | Contents |
|---|---|---|
| Microduck robot | $399 | Robot, battery, USB-C cable, game controller |
| Charger pack | $39 | Dual charger, 2x batteries |
| Dev pack | $119 | 3x spare motors, 5x motor cables, 2x batteries, dual charger, 10x NFC tags, Hugging Face credit, screwdriver, screw pack |
| Accessory pack | $39 | Laser pointer, NFC polaroid, 2x rollers, ball, 10x NFC tags |
Read the dev pack again. Three spare motors and a screwdriver, sold as the developer configuration.
That is Pollen telling you, in inventory rather than in prose, what training reinforcement learning on a 15-actuator biped actually involves: your policy will fall over, repeatedly, on purpose, for hours, and servo gears will strip. A "get back up" policy exists because getting knocked down is the normal state of the system. Anyone budgeting $399 for this should mentally budget $518 and a spare afternoon with a screwdriver.
Set against the rest of the affordable-robot field explainx.ai has tracked in 2026 — Nori L2 pitching an iPhone-priced robot from a waitlist page, OOMWOO going viral as an open-source vacuum whose files were not actually published — Microduck's distinguishing feature is that the software you would want to inspect exists today, before the hardware ships. Historically in this category it is the other way around.
The living-room question
The sharpest reply under Delangue's announcement was not about price. It was about what $399 puts in your house:
"the real story: $399 to put a camera, a mic and a LiDAR in someone's living room. open-source is the only reason that's acceptable. you can read what it sends home. closed consumer robots will never survive that audit, and people are about to start asking."
That reply is correct, and it deserves to be taken as the strongest argument for the product rather than against it.
A camera, microphones, and a depth sensor mapping the floor plan of your home is a serious sensor payload at any price. The difference between Microduck and a closed consumer robot with identical hardware is not intent — it is verifiability. The firmware is Apache-2.0. The processes are named daemons on local Unix sockets. Camera streaming is an identifiable service (mediad, over WebRTC) rather than an opaque blob. Updates are signed with a rollback path. You can watch what leaves the device and, if you disagree with it, fork the thing that sent it.
That is a materially different privacy posture from the home-robot category generally, and it is the strongest practical case for open weights and open firmware that consumer robotics has produced this year. It is also, in fairness, only a capability to audit — nobody is claiming most buyers will read mediad. The claim is that a few will, publicly, and that closed competitors cannot offer even that.
Why a duck, three days into a $12.9 billion story
Here is the part that makes this more than a gadget post.
Hugging Face spent this week as the subject of the biggest open-weight infrastructure story of the year: The Information reported Nvidia agreed to buy it for $12.9 billion, while Business Insider and Bloomberg reported talks above $13 billion with no deal reached. Neither company has confirmed anything on the record. It remains contested reporting, not a closed transaction — and nothing in the Microduck announcement addresses it.
And the first major public move Hugging Face makes into that news cycle is… a $399 duck.
It reads like a punchline. It is closer to a thesis. Hugging Face's original wedge was never a datacenter product — it was pip install transformers, a free artifact that put the whole NLP ecosystem's default workflow inside its own tooling before anyone thought to charge for it. Distribution first, monetisation later, standards ownership permanently.
Microduck is that play, aimed at physical AI:
| The Transformers play (NLP) | The Microduck play (physical AI) |
|---|---|
| Free library, trivially installable | $399 robot, assembled, playable on arrival |
| The Hub became where weights live | Policy sharing becomes where behaviours live |
| Fine-tuning tutorials as the on-ramp | Sim-to-real RL training as the on-ramp |
| Compute and enterprise tiers monetise later | Hugging Face Jobs monetises the training loop |
Robotics currently lacks what NLP had in 2019: a large population of practitioners who have personally trained a policy and deployed it to hardware. China's answer has been industrial-scale humanoid training schools — dedicated facilities generating embodied data at scale. Hugging Face's answer is to hand tens of thousands of individuals a biped small enough to fall off a desk without consequence, and make publishing your policy the natural last step.
If you are trying to own the distribution layer for world models the way you owned it for language models, a cheap thing with legs in a lot of homes is not a distraction from the strategy. It is the strategy — and it is one that survives a change of ownership better than a datacenter roadmap does.
Who should actually buy one
Buy it if you are learning control or embodied AI. This is the clearest self-contained sim-to-real curriculum available at this price. You get a real reward function to modify, real domain randomization to tune, a real reality gap to close, and a physical object that either walks or does not — feedback that no notebook exercise provides. For anyone teaching embodied AI, the fact that the entire stack is readable turns it from a demo into a syllabus. explainx.ai's own centre of gravity is live teaching, and hardware where every layer is inspectable is rare enough to be worth saying out loud.
Buy it if you want an RL testbed with a real actuator model. A modelled Dynamixel XL330 with back-EMF and Stribeck friction, plus optional gear backlash, is a more honest sim than most course projects ever touch.
Do not buy it expecting an assistant. There is no on-device language model in the announcement. Open Duck Mini's Gemma 4 demo was a different capability on adjacent hardware, and conflating the two will disappoint you. This is a locomotion platform.
Do not buy it expecting to skip the GPU question. Either you have CUDA, or you are training on Hugging Face Jobs. There is no third path today.
Do not buy it as a finished product. It is a pre-order with a stated Christmas window, from a company whose parent is in the middle of contested acquisition reporting.
What is still unknown
Being straight about the gaps matters more than filling them with guesses:
- Battery life is not published. The product page and the README both omit runtime per charge. The existence of a $39 dual-charger pack with two batteries is a hint, not a number.
- RAM and storage on the RK3566 are not stated in the material published so far.
- The seventh policy is unnamed — six moves are described against a "7 policies" claim.
- Shipping regions: coverage points at North America and Europe first; the product page itself does not enumerate regions.
- Pre-trained checkpoint distribution — the training repo implies trained policies exist, but does not clearly state that every shipped checkpoint is downloadable from the repo itself.
- The 15 motors vs 14 modelled joints gap has no published explanation.
- Nothing about Microduck is contingent on the Nvidia reporting, and nothing in the launch comments on it.
Bottom line
Microduck is the moment the open-source duck stopped being a 3D-printing project and became a SKU. Same lineage, same rough price, radically different accessibility: no printer, no BOM sourcing, no wiring — and, crucially, no reduction in what you are allowed to read and change. Apache-2.0 firmware, published MuJoCo training environments, ONNX export, hot-swappable policies at 50 Hz onboard.
The strategic read is that Hugging Face believes physical AI needs the same thing NLP needed in 2019 — not a better model, but a wide population of people who have personally closed a sim-to-real loop. At $399 with a game controller in the box, that population gets a lot larger.
The honest caveat is that none of it is in anyone's hands yet. Pre-orders opened today; hardware ships before Christmas, allegedly. The code, at least, you can read tonight.
Related on explainx.ai
- Gemma 4 powers Open Duck Mini — the on-device predecessor
- Nvidia's reported $12.9B Hugging Face deal — contested reporting explained
- Matic Cues — on-device robot AI on a Jetson Orin Nano
- OOMWOO — the open-source robot vacuum that was not buildable yet
- Nori L2 — a sub-iPhone-price robot on a waitlist
- Xiaomi U0 — world foundation models for embodied synthesis
- NVIDIA MotionBricks — real-time motion on the Unitree G1
- China's humanoid robot training schools
Primary sources (cited, not linked): the Microduck product page at pollen-robotics.com/microduck, the control repository pollen-robotics/microduck, and the training repository pollen-robotics/microduck_rl on GitHub. Announcement quotes are from Clement Delangue and Thomas Wolf on X, August 27, 2026. Bloomberg reported the launch as "Hugging Face Unveils $400 Singing, Skating Duck-Like Robot" the same day.
Specs, pricing, SKU contents, license terms, and repository details reflect the Microduck product page and public repositories as of August 27, 2026 — launch day. Pre-order pricing is described by Pollen Robotics as introductory and excludes taxes and shipping; the "before Christmas 2026" delivery window is a stated target, not a shipped result. Repository contents on an actively developed project change quickly — check the repos directly before relying on any training detail here.