Robot design · v0.1

What kind of robot is MiniDuck?

Engineering codename: Octopus Nova Rover. A white oval body with orange trim, exposed joints and yellow wheel covers. It is a desktop-sized wheel-legged robot that can balance, move, see and listen on flat indoor floors.

Illustration of the MiniDuck wheel-legged robot
Please note: everything on this page comes from engineering design plan v0.1 (November 2026). These are design targets and early estimates that have not been tested on real hardware. Dimensions, joint positions and actuator models still need to be confirmed in simulation, and we will post every change in the build log.

V1 design targets

LayoutTwo wheels + two joints per leg (hip and knee)
Degrees of freedom4 leg joints + 2 wheel drives
HeightAbout 280–330 mm
WeightTarget 2–3 kg
Top speedLimited to 0.3 m/s at first
Self-balancingStanding, driving forward and back, turning
InteractionVoice, camera, LED expressions
AINova Agent, vision-language model (VLM), tool calling
EnvironmentFlat indoor floors, no stairs
Battery lifeTarget 30–60 minutes

V1 will not jump or do stunts. Stable standing, driving, fall detection and safe shutdown come first; getting back up and dynamic moves come later.

Mechanics

Six joints, left and right

Joint layout

  • Left hip L-HIP · left knee L-KNEE · left wheel L-WHEEL
  • Right hip R-HIP · right knee R-KNEE · right wheel R-WHEEL

This naming and basic structure match the open-source Upkie robot, so we can build on its kinematics and control code.

Materials

  • Shell: 3D-printed PETG, 2.5–3 mm walls
  • Joint brackets: aluminium
  • Fasteners: steel
  • Tyres: non-slip TPU

The printed shell does not carry the joint loads; the metal brackets do.

PartStarting dimension
Body shell180 × 110 × 85 mm
Thigh link80 mm
Shin link85 mm
Wheel diameter90 mm
Track width190–220 mm

These are starting points for CAD. We still need to check tyre clearance, joint range, centre of mass and room for wiring.

The first big decision

Not the AI model, but the actuators

Actuators are the robot’s muscles. If the joint motors are not strong, fast or precise enough, no amount of clever AI will make the robot stand.

Cheap serial bus servos are fine for early structural tests, but the kg·cm number on the box is not enough. We need to measure continuous torque, speed, backlash, heating and control latency.

So for the first two weeks we do the dynamics maths and test actuators before buying parts for the whole robot.

A quick calculation

Assume the robot weighs 2.5 kg, its centre of mass is 0.15 m above the wheel axle, and it leans 10°:

τ ≈ m·g·h·sin(10°) ≈ 0.64 N·m

This is a simplified estimate of the overall tipping torque from gravity, not the torque each motor needs. The real numbers also depend on acceleration, wheel grip, gear ratio and impacts.

We will simulate three cases: standing still, balancing while speeding up and slowing down, and recovering from a squat. We will lock in the actuator model only after we know the peak and continuous torque.

Software architecture

Nova Agent + Robot Runtime

The AI sends an intent. The Robot Runtime checks it, carries it out and reports back. The lower the layer, the faster it runs, the closer it is to the hardware, and the higher its priority.

Nova Agent / AI BrainLLM · VLM · memory · planner · tool calling
Robot Skills APImove · turn · look · squat · speak · stop
ROS 2 · Raspberry Pi 5Perception (vision, speech, localisation) · motion planning (speed, posture, trajectory)
STM32 real-time controllerIMU fusion · PID/LQR balance · motor control · watchdog
Hardware4 joint actuators · 2 wheel motors · sensors
ModulePlanned technologyUpdate rate
Motor current loopInside the motor driver1–20 kHz
Balance controlSTM32 C/C++500–1,000 Hz
State estimationIMU + encoder fusion200–500 Hz
Motion planningROS 2 / C++20–100 Hz
VisionOpenCV / VLM5–30 FPS
Speech recognitionWhisper or another ASREvent-driven
Agent decisionsNova AgentEvent-driven
MemorySQLite / vector databaseOn demand

Rates are design targets. Whether we hit them depends on the hardware, the drivers and real-time scheduling tests.

Nova Robot Skills

“Come and look at what’s on the table”

When you say this to MiniDuck, the system works through these steps:

  1. Nova understands the task and finds the target
  2. Vision locates the target and any obstacles
  3. Motion planning works out an allowed path
  4. The controller keeps balance while driving
  5. On arrival, the camera takes a picture
  6. The VLM describes the object and answers out loud

Every action is a Skill call with safety limits attached:

{
  "robot_id": "nova-rover-001",
  "skill": "move",
  "arguments": {
    "direction": "forward",
    "distance_m": 0.5,
    "max_speed_mps": 0.15
  },
  "safety": {
    "obstacle_check": true,
    "require_balance": true,
    "timeout_ms": 10000
  }
}
The safety controller has the final say. If the link drops, the robot tips over, a motor draws too much current or overheats, or the e-stop is pressed, it stops accepting new actions and moves to a verified safe state.
Simulation & digital twin

Fall over a thousand times in software first

MuJoCo

Fast iteration on dynamics, joint models, balance algorithms and control gains.

NVIDIA Isaac Sim

Simulates the wheel-legged robot, its sensors and indoor scenes. Later we can try reinforcement learning with Isaac Lab.

Starting from Upkie

Upkie has open-sourced Python/C++ control, PyBullet simulation and balancing examples. We start there and move to MiniDuck’s own URDF model.

We changed the actuators, dimensions, weight and wheel size, so Upkie’s balance tuning will not carry over. We have to simulate and tune again.

Roadmap

The 12-week plan

Weeks 1–2

Mechanics & simulation

CAD, URDF, centre-of-mass calculation, actuator selection and a first balance simulation.

Deliverables: CAD v0.1, BOM v1, working simulation
In progress
Weeks 3–4

Hardware build

3D-print the shell, fit the wheel drives, joints, sensors and power system, and test each actuator.

Deliverable: a prototype that powers on
Planned
Weeks 5–6

Balance control

State estimation, wheel speed control, standing balance and basic forward and backward motion.

Deliverable: self-balancing in a protected test area
Planned
Weeks 7–8

ROS 2 & motion interface

Speed control, turning, squatting, remote control, status feedback and the emergency stop.

Deliverable: Robot Runtime v0.1
Planned
Weeks 9–10

Nova Agent integration

Camera, microphone, voice interaction, task planning and Robot Skills.

Deliverable: understands instructions and carries out controlled actions
Planned
Weeks 11–12

Integration & acceptance

Obstacle detection, fault protection, battery testing, the demo routine and operating docs.

Deliverable: MiniDuck V1 demo
Planned

V1 acceptance tests

TestPass criteria
Self-balancingStays balanced on a flat floor for 60 seconds
DrivingDrives 2 m forward, stops and reverses
TurningTurns 90° on the spot
VoiceRecognises and carries out 5 predefined commands
VisionRecognises a named object and describes it
SafetyE-stop, link-loss and fall protection all work
BatteryAt least 30 minutes, measured
LoggingRecords actions, sensor data and errors

We will post the result of every test, pass or fail, in the build log.

Open source

Standing on the shoulders of the open-source community

We start from Upkie’s proven balance control, then replace the shell, computer, sensors and AI piece by piece. MiniDuck’s code will be organised as shown here. Later, Nova Agent’s physical AI layer could become an SDK for robots of other shapes.

References: Upkie on GitHub · Upkie build guide

nova-rover/
├── hardware/      # CAD, electronics, BOM
├── firmware/
│   └── stm32-motion/
├── robot-runtime/
│   ├── ros2/  perception/
│   └── motion/  safety/
├── nova-agent/
│   └── skills/  planner/  memory/
├── simulation/
│   └── urdf/  mujoco/  isaac/
└── tests/