Microduck: A $399 Robot That Learns to Walk — And How to Build Your Own RL Robot

By Prahlad Menon Published 2026-08-30 3 min read

A tiny robot duck just learned to walk, stand up after being knocked over, and pick things up with its beak — all using reinforcement learning. Microduck from Pollen Robotics is a 25cm, 800g biped that runs neural network policies on a standard ARM chip, and it’s available for pre-order at $399.

But more importantly: the entire software stack is open source, and the techniques transfer to any robot you can simulate.

What Makes Microduck Different

Most hobbyist robots use pre-programmed gaits or inverse kinematics. Microduck uses learned policies — neural networks trained in simulation that control the robot’s 15 servos at 50Hz. The results:

Walking with a gamepad
Self-recovery from falls (no human intervention needed)
Object grasping with an articulated beak
Roller mode — swap to wheels and it loads a different “brain”

The sim-to-real pipeline is the real innovation: train in MuJoCo simulation, export to ONNX, deploy to hardware.

Hardware Specs

Component	Specification
Height	25 cm
Weight	~800 g
Motors	15 servos
Compute	Rockchip RK3566 (ARM)
Sensors	Camera, LiDAR, 2× IMU
Control	50Hz neural policy loop
Software	Rust (no framework)
Price	$399 (pre-order)

Where to get one: pollen-robotics.com/microduck

Shipping targets Christmas 2026 for North America, Europe, and UK.

The Software Stack

Everything runs on the robot itself — no cloud required:

robotd      → Control loop, motor bus, policy execution
updaterd    → Safe OTA updates with rollback
configd     → WiFi, identity
btd         → Bluetooth for phone/gamepad
padd        → Gamepad input
mediad      → WebRTC camera streaming
tofd        → Depth sensor

All daemons communicate over Unix sockets with JSON-RPC. The same API works whether you’re controlling from a gamepad, phone app, or your own script.

Repos:

Robot software: github.com/pollen-robotics/microduck
RL training: github.com/pollen-robotics/microduck_rl

Getting Started with Microduck

Day 1: Play Mode

Out of the box, Microduck comes with pre-trained behaviors. Pair a gamepad and drive:

robotctl gamepad pair
# Then use left stick to walk, triggers for actions

Key commands from the cheat sheet:

robotctl drive         # Manual control mode
robotctl sit           # Sit down
robotctl standup       # Recovery from fall
robotctl voice quack   # Yes, it quacks

Day 2: Modify Behaviors

Connect over Bluetooth from your laptop (no SSH/WiFi needed):

duckctl connect
duckctl policy list
duckctl policy load my_custom_walk.onnx

Day 3+: Train Your Own Policies

The real power is training custom behaviors. Clone the RL repo:

git clone https://github.com/pollen-robotics/microduck_rl
cd microduck_rl
pip install -e .

Training uses MuJoCo for simulation and PPO (Proximal Policy Optimization) for learning:

# Simplified training loop concept
env = MicroduckEnv()  # MuJoCo simulation
policy = PPO("MlpPolicy", env)
policy.learn(total_timesteps=1_000_000)
policy.save("walk_v2.onnx")

The trained ONNX model deploys directly to the robot.

DIY: Apply This to Any Robot

Don’t have $399? The Microduck approach works on anything you can simulate. Here’s the general recipe:

Step 1: Build or Buy Hardware

Options from cheap to expensive:

Platform	Cost	Complexity
Servo-based arm (5-6 DOF)	$50-150	Low
Quadruped kit (Petoi Bittle)	$250	Medium
Custom 3D-printed biped	$100-300	High
Microduck	$399	Medium
Used Unitree Go1	$1000+	High

For beginners: start with a servo arm. Fewer joints = faster training.

Step 2: Create a Simulation

MuJoCo is free and excellent. Define your robot in MJCF (XML):

<mujoco>
  <worldbody>
    <body name="base">
      <joint type="free"/>
      <geom type="box" size="0.1 0.05 0.02"/>
      <body name="leg1" pos="0.05 0 -0.02">
        <joint name="hip1" type="hinge" axis="0 1 0"/>
        <geom type="capsule" size="0.01" fromto="0 0 0 0 0 -0.1"/>
        <!-- More joints... -->
      </body>
    </body>
  </worldbody>
  <actuator>
    <motor joint="hip1" ctrlrange="-1 1"/>
  </actuator>
</mujoco>

Alternatively, use PyBullet (also free) or Isaac Gym (faster but NVIDIA GPU required).

Step 3: Define a Reward Function

This is where the magic happens. For walking:

def compute_reward(self):
    # Reward forward velocity
    forward_vel = self.robot.velocity[0]
    
    # Penalize falling
    height = self.robot.base_height
    alive_bonus = 1.0 if height > 0.1 else 0.0
    
    # Penalize energy use
    energy_penalty = -0.01 * np.sum(np.abs(self.actions))
    
    return forward_vel + alive_bonus + energy_penalty

Key insight: reward shaping is 90% of the work. Start simple, iterate.

Step 4: Train with PPO

Stable-Baselines3 makes this easy:

from stable_baselines3 import PPO
from your_env import RobotEnv

env = RobotEnv()
model = PPO(
    "MlpPolicy",
    env,
    learning_rate=3e-4,
    n_steps=2048,
    batch_size=64,
    verbose=1
)
model.learn(total_timesteps=2_000_000)
model.save("robot_walk")

Training time: a few hours on a decent CPU, minutes on GPU.

Step 5: Domain Randomization

The secret to sim-to-real transfer. Randomize everything:

# During training, vary these each episode:
self.friction = np.random.uniform(0.5, 1.5)
self.mass = self.default_mass * np.random.uniform(0.9, 1.1)
self.motor_strength = np.random.uniform(0.8, 1.2)
self.observation_noise = np.random.normal(0, 0.01, obs.shape)

If the policy works across randomized simulations, it usually works on real hardware.

Step 6: Deploy to Hardware

Export to ONNX for efficient inference:

import torch

# Load trained policy
model = PPO.load("robot_walk")

# Export to ONNX
dummy_input = torch.randn(1, observation_dim)
torch.onnx.export(
    model.policy,
    dummy_input,
    "robot_walk.onnx",
    input_names=["observation"],
    output_names=["action"]
)

Run on the robot (Python, C++, or Rust — ONNX Runtime works everywhere):

import onnxruntime as ort

session = ort.InferenceSession("robot_walk.onnx")

while True:
    obs = read_sensors()
    action = session.run(None, {"observation": obs})[0]
    send_to_motors(action)
    time.sleep(0.02)  # 50Hz control loop

Resources to Go Deeper

Simulation:

MuJoCo — Free, fast, accurate
PyBullet — Python-native, easier to start
Isaac Gym — GPU-accelerated, 10-100x faster

RL Libraries:

Stable-Baselines3 — PPO, SAC, etc.
CleanRL — Single-file implementations
RSL-RL — Legged robot focused

Open Hardware:

Petoi Bittle — $250 quadruped with servo control
Open Dynamic Robot Initiative — Research-grade designs
James Bruton’s YouTube — DIY bipeds and quadrupeds

Papers:

Learning to Walk in Minutes — Isaac Gym massively parallel training
Sim-to-Real Robot Learning — Domain randomization techniques

Why This Matters

Microduck isn’t just a cute robot — it’s a sign that embodied AI is becoming accessible. The same techniques powering Boston Dynamics and Figure robots now run on a $399 duck.

The implications:

Education — Students can learn RL on real hardware, not just Atari games
Prototyping — Test locomotion ideas in hours, not months
Research — Multi-robot experiments without a lab budget
Hobbyists — Build robots that actually learn

The barrier to entry just dropped dramatically. If you can write a reward function and wait for training to converge, you can make a robot walk.

Links:

Pre-order Microduck: pollen-robotics.com/microduck
Robot code: github.com/pollen-robotics/microduck
RL training: github.com/pollen-robotics/microduck_rl
Hugging Face (models): Coming soon
Discord: Pollen Robotics Community