Legged & Quadruped Robot Hardware: The Ultimate Guide

A wheel is a beautiful solution to a flat-world problem. The moment the world stops being flat — stairs, rubble, mud, a 200 mm curb, a catwalk in a substation — the wheel's elegance becomes a liability and you start wishing you had feet. Legged robots exist to put a foot exactly where they choose, ignore everything in between, and keep a payload level while the ground beneath does whatever it wants.

This is the long version of how that hardware actually works. We'll go through why you'd pick legs at all, the 2026 quadruped roster you can actually buy, leg kinematics and the standard 3-DoF leg, the quasi-direct-drive (QDD) actuator revolution that made dynamic legged robots practical, the gaits and control rates that drive the hardware spec, sensing and state estimation, power and runtime, why four legs is genuinely easier than two, the honest applications, and how to choose or build one. Real numbers with units, real products, opinions with reasons attached.

The take: Legged robots are not better than wheels — they are more expensive, less efficient, and less reliable per meter traveled, and they win only when the terrain denies wheels entirely. What changed between 2015 and 2026 is not that legs got cheaper to run but that they got cheaper to build: the MIT Cheetah insight — a low-ratio brushless motor running field-oriented control is a backdrivable, force-controllable, impact-tolerant actuator — collapsed the cost and complexity of a usable leg by an order of magnitude, and Unitree turned that into a sub-$3,000 quadruped. The actuator is the whole story; everything else is plumbing around it.

Companion reading: robot actuators, quasi-direct-drive & BLDC motors, motor controllers & FOC, and humanoid robot hardware.

Table of contents

1. Key takeaways
2. Why legs at all
3. The 2026 quadruped roster
4. Leg design & kinematics
5. The QDD actuator revolution
6. Why QDD beat geared-plus-sensor legs
7. Gaits & dynamics: what the hardware must do
8. Sensing for locomotion
9. Balance & control: MPC, WBC, and RL
10. Power & runtime
11. Bipeds vs quadrupeds
12. Applications & honest ROI
13. Building or selecting a legged robot
14. Frequently asked questions

Why legs at all

Start with the uncomfortable truth: for almost every job a mobile robot does, wheels are the right answer. They're efficient, simple, cheap, and reliable. If you're moving boxes across a warehouse floor, building a legged robot to do it is engineering malpractice. See the mobile robots (AMR/AGV) guide for the world where wheels rightly dominate.

Legs earn their place on exactly one axis: terrain that wheels and tracks cannot negotiate. Discrete footholds. A robot with legs touches the ground only where it chooses to, and ignores everything in between. A wheel must roll over (or fail to roll over) every point along its path; a leg steps across the bad parts. That is the entire value proposition, and it is a real one for stairs, rubble fields, gaps, steep loose slopes, and the cluttered interiors of industrial plants designed for humans.

The cost-of-transport tax

The price of that capability is energy. The standard dimensionless metric is the cost of transport (CoT), also called specific resistance:

CoT = E / (m · g · d)

  E = energy used to travel distance d  [J]
  m = total mass                        [kg]
  g = 9.81 m/s^2
  d = distance traveled                 [m]

Lower is better. CoT is dimensionless.

Reference points:
  Freight train          ~0.02
  Bicycle (human)        ~0.05
  Automobile             ~0.1 - 0.3
  Walking human          ~0.2
  Wheeled mobile robot   ~0.1 - 0.3
  Boston Dynamics Spot   ~0.5 - 0.7   (electric, modern)
  Early legged robots    >1.0 - 3.0   (hydraulic era)

Rule of thumb: a modern electric quadruped costs roughly 2–5× more energy per meter than a wheeled robot of similar mass on flat ground. You are buying terrain access with battery.

The hydraulic-era machines (early Atlas, BigDog) were far worse — CoT often above 1.0 — because hydraulic power units dump enormous energy as heat. The shift to electric QDD actuators is the single biggest reason CoT dropped into the 0.5 range, which is what made battery-powered legged robots useful for more than a demo.

When legs actually win

Be honest with yourself about the use case. Legs win when all of these are true: the terrain is genuinely non-wheelable, the mission tolerates 1–4 hour runtimes, and the value of the data or task at the far end justifies a $30k–$150k machine. That describes substation and oil-and-gas inspection, underground mining, disaster response, construction site monitoring, and research. It does not describe warehouse logistics, last-mile delivery on sidewalks (wheels plus a small step-climb mechanism usually win), or your living room floor.

There's also a hybrid answer worth respecting: wheeled legs (wheels on the end of articulated legs, like ANYbotics' and Swiss-Mile's research platforms, or the DEEP Robotics wheeled variants). These roll efficiently on flat ground and walk only when they must, clawing back much of the CoT gap. If your environment is 90% flat with occasional steps, that's often the smart hardware choice.

The 2026 quadruped roster

Here is the landscape you can actually procure in 2026, from premium industrial to disruptive consumer-research. Numbers are manufacturer-published or well-established field figures; treat price especially as approximate and configuration-dependent.

Robot	Mass	Payload	Top speed	Runtime	DoF	Indicative price
Boston Dynamics Spot	~32–34 kg	~14 kg	~1.6 m/s	~90 min	12	~$75,000+
Unitree Go2 (Air/Pro/EDU)	~15 kg	~8 kg	up to ~3.5–5 m/s	~1–2 h	12	~$1,600–$16,000
Unitree B2	~60 kg	~40 kg (up to ~120 kg static)	~6 m/s	~2–4 h	12	~$100,000
Unitree A1 (legacy)	~12 kg	~5 kg	~3.3 m/s	~1–2.5 h	12	~$10,000 (discontinued)
ANYbotics ANYmal (D/X)	~50 kg	~10–15 kg	~1.3 m/s	~2–4 h	12	~$150,000+
Ghost Robotics Vision 60	~51 kg	~10–14 kg	~3 m/s	~3 h	12	~$100,000+
DEEP Robotics X30	~56 kg	~20 kg	~4 m/s	~2.5–4 h	12	~$50,000+
MIT Mini Cheetah (research)	~9 kg	small	~2.5+ m/s	~lab	12	research platform

A few editorial notes on this table:

Spot is the reference design for industrial inspection: rugged, IP54, a mature SDK, a real payload ecosystem (the Spot CAM, the arm, third-party sensor packages), and the only one with a serious commercial deployment story across dozens of industries. You pay for the ecosystem and the reliability, not the raw specs.

Unitree is the disruptor. The Go2 at consumer prices put a capable QDD quadruped in every robotics lab's budget, and the B2 is a serious industrial machine at a fraction of Western pricing. The catch is the export, support, and data-governance questions that make some Western industrial and defense buyers nervous.

ANYmal (a spinout from ETH Zurich) is the research-pedigree industrial platform — exceptional terrain capability, strong autonomy stack, IP67-class sealing for harsh industrial environments, and the deepest published academic record (it's the platform behind much of the leading RL-locomotion research).

Ghost Robotics Vision 60 leans into defense and security: rugged, all-weather, and notable for designs that tolerate operating inverted and self-righting.

DEEP Robotics (X30, Lite3, Lynx wheeled-leg) is the other strong Chinese player, with a focus on industrial inspection and an impressive stair/terrain record.

Leg design & kinematics

The standard 3-DoF leg

Almost every modern quadruped uses the same leg topology: three actuated joints per leg, twelve total.

1. Hip abduction/adduction (HAA) — roll axis, swings the whole leg outward and inward from the body. This is what lets the robot widen its stance for stability and shift weight laterally.
2. Hip flexion/extension (HFE) — pitch axis, swings the upper leg (thigh) forward and back. The main propulsion joint.
3. Knee flexion/extension (KFE) — pitch axis at the knee, folds the lower leg (shank). Sets foot height and, with the hip, foot reach.

Three DoF is the minimum to place the foot anywhere in a 3D workspace and still have enough control authority over body roll, pitch, and height. You can build 2-DoF legs (cheaper, planar-only, fine for a toy or a treadmill experiment), but you give up lateral balance and the ability to recover from sideways pushes. Nobody serious ships 2-DoF.

Serial vs parallel, and where the motors live

Two big architectural choices shape the leg:

Where you put the actuators. The dynamics-friendly trick — pioneered hard by MIT Cheetah and adopted widely — is to co-locate the heavy motors near the hip/body and drive the knee through a linkage or belt, so the lower leg is light. Leg swing dynamics are dominated by the inertia of the distal links; a light shank means the leg can be accelerated fast (essential for dynamic gaits) and means less energy lost on every step. Spot, Unitree, and ANYmal all cluster mass proximally.

Serial vs parallel linkage. A serial leg stacks joint-on-joint (motor at hip, motor at knee mounted on the thigh). A parallel/coaxial design mounts both pitch motors at the hip and drives the knee through a four-bar or a pushrod, keeping the shank a near-massless strut. Parallel mechanisms reduce distal inertia at the cost of kinematic complexity and a workspace that's harder to reason about. Most high-performance quadrupeds use some parallel element for the knee.

The leg Jacobian: turning torque into foot force

The reason QDD legs can do force control without a force sensor lives in the leg Jacobian, which maps joint velocities to foot velocity and (by the transpose) joint torques to foot force:

Foot velocity:     v_foot = J(q) · q_dot
Foot force <-> joint torque:   tau = J(q)^T · F_foot

  q       = joint angles            [rad]   (e.g. [HAA, HFE, KFE])
  J(q)    = leg Jacobian (3x3 for a 3-DoF leg)
  v_foot  = foot Cartesian velocity [m/s]
  tau     = joint torques           [N·m]
  F_foot  = Cartesian foot force    [N]

Because a QDD joint lets you estimate tau from motor current,
you can read foot force F_foot = J^-T · tau and command it back
through tau = J^T · F_foot_desired — no load cell at the foot.

Key insight: with backdrivable, torque-transparent joints, the whole leg becomes a programmable spring/damper. You command a desired foot force as a function of foot position and velocity (an impedance), and the robot lands soft, absorbs impacts, and conforms to terrain — all in the actuator, no fancy feet required.

This is also why motion planning for legged robots is its own discipline: you're not just placing a foot, you're choosing footholds, swing trajectories, and contact forces simultaneously. See the motion planning & kinematics guide for the trajectory and inverse-kinematics machinery underneath.

The QDD actuator revolution

If you remember one thing from this guide, remember this section. The quasi-direct-drive actuator is the reason legged robots went from million-dollar lab curiosities to $3,000 commodities.

The MIT Cheetah insight

The conventional robotics actuator is a small, fast motor behind a high-ratio gearbox (50:1, 100:1, even 160:1 harmonic drives — see the gearboxes guide). That gives you enormous torque from a tiny motor, beautiful position accuracy, and a joint that holds position with the power off. It is the right answer for an industrial arm.

It is the wrong answer for a leg, and the MIT Biomimetic Robotics Lab (Sangbae Kim's group) made the argument concrete around 2013–2018. A leg has to do three things a high-ratio gearbox is terrible at:

1. Survive impacts. Every footfall is a collision. A high-ratio gearbox reflects the motor's inertia to the output multiplied by the ratio squared — the joint feels enormously heavy and brittle on impact, and the gear teeth take the shock.
2. Be backdrivable. A leg must yield to the ground, not fight it. High-ratio gears (especially harmonic and worm) are barely backdrivable; the leg behaves like a rigid stick.
3. Control force fast and cleanly. Force control through a stiff high-ratio gearbox means bolting on a torque sensor and closing a loop around its noise and the gearbox's friction/backlash.

The QDD answer: use a big, high-torque, low-KV brushless motor and a single-stage planetary gearbox with a low ratio — roughly 6:1 to 10:1. Run it with field-oriented control (FOC), which lets you command motor torque directly (torque is proportional to quadrature-axis current). Now the gear ratio is low enough that:

• The motor is backdrivable through the gearbox by hand.
• Joint torque is proportional to motor current, which you already measure for FOC. You get a torque sensor for free — proprioceptive torque sensing.
• Reflected inertia is small, so the joint tolerates impacts and the control loop sees a clean, near-linear plant.

Reflected inertia at the joint output:

  J_reflected = N^2 · J_motor + J_gear_output

  N        = gear ratio
  J_motor  = motor rotor inertia [kg·m^2]

Because reflected inertia scales with N^2, dropping from a 100:1
harmonic drive to an 8:1 planetary cuts the reflected rotor
inertia by ~(100/8)^2 ≈ 156x. That is the difference between a
leg that shatters on impact and one that bounces.

Backdrive torque (torque you must apply at the output to move
the motor backward through the drive):

  tau_backdrive ≈ (J_motor · N · alpha_out) / eta_backdrive
                  + friction terms

Low N and high gearbox efficiency (eta) keep this tiny.
For an 8:1 single-stage planetary at ~90% efficiency the leg
backdrives with a few N·m — you can push it with one hand.
A 100:1 harmonic drive may need tens of N·m and a lot of
breakaway friction; effectively non-backdrivable.

For more on the motor and drive side of this, see the BLDC motors guide (pole count, KV, torque density) and the FOC motor-controllers guide (how current becomes torque at 20+ kHz).

What a real QDD module looks like

A modern QDD leg module — MIT Cheetah's actuator, Unitree's GO-M8010, the open-source MJBots qdd100, or T-Motor's AK-series — is a tidy package:

• A large-diameter, high-pole-count (often 14–21 pole-pair) outrunner BLDC, optimized for torque density at low speed.
• A single-stage planetary gearbox, 6:1–10:1, with low friction and good backdrive efficiency.
• An integrated FOC drive on a board inside the housing, talking CAN or EtherCAT.
• Two encoders — one on the rotor (commutation + velocity), one on the output (absolute joint angle), so you read both motor and joint position. See the encoders guide.
• Continuous torque on the order of 15–35 N·m with peak torque 2–4× that for impact and dynamic moves, in a package weighing ~0.5–1.0 kg.

That last point matters: per-actuator torque density (N·m/kg) is the spec that sizes the whole robot. Higher torque density means a lighter leg, which means lower distal inertia, which means faster, more dynamic gaits. It's a virtuous loop the whole industry is climbing.

Why QDD beat geared-plus-sensor legs

It's worth laying the two philosophies side by side, because the choice isn't obvious until you've felt both fail.

Property	High-ratio gearbox + torque/force sensor	QDD (low ratio + FOC, proprioceptive)
Gear ratio	50:1 – 160:1 (harmonic)	6:1 – 10:1 (single-stage planetary)
Backdrivability	Poor to none	Excellent
Torque sensing	Dedicated sensor (load cell / strain gauge)	From motor current — "free"
Impact tolerance	Low — gear teeth + sensor take shock	High — low reflected inertia, motor cushions
Control bandwidth	Limited by sensor noise + gearbox dynamics	High — clean near-linear plant, 1+ kHz
Reflected inertia	High (∝ N²)	Low
Position accuracy	Excellent	Good (needs output encoder)
Efficiency (steady load)	High at the gearbox; motor small	Lower gear loss; motor runs harder
Cost / complexity	High (precision gears + sensors)	Lower (commodity motor + board)
Holds position, power off	Yes (self-locking)	No — must hold with current
Best for	Precise arms, slow heavy joints	Dynamic legs, contact-rich motion

The geared-plus-sensor approach isn't wrong — it's exactly right for a precision industrial arm, where you want stiffness, accuracy, and the joint to hold position when de-energized. It's wrong for a leg, where the dominant requirements are impact survival, transparency, and torque bandwidth.

The gearbox-ratio sweet spot for legs is roughly 6:1 to 10:1. Below ~6:1 you can't get enough torque without a huge, heavy motor. Above ~10:1 you start losing backdrivability and gaining reflected inertia, and you're sliding back toward the geared-arm regime. Most QDD leg modules cluster at 7:1–9:1.

There's a cost to QDD honesty: because the joint is not self-locking, the robot burns current just to stand still holding a pose (gravity compensation), and it can't go limp-but-locked when powered off. That standing-power cost is a real chunk of the runtime budget and one reason legged robots crouch and sit when idle.

Gaits & dynamics: what the hardware must do

The gait you want determines the control rate you need, which determines the actuator bandwidth you must buy. Hardware follows from dynamics.

Static vs dynamic gaits

A static gait keeps the robot's center of mass inside the support polygon (the convex hull of feet on the ground) at all times. A quadruped walking by lifting one leg at a time always has a stable tripod under it. It's slow, safe, and — crucially — doesn't require fast control. A static crawl can be run at modest loop rates and survives clumsy hardware. This is how you climb a ladder-like obstacle carefully.

A dynamic gait — trot (diagonal pairs), pace, bound, gallop, pronk — deliberately leaves the robot statically unstable for part of the cycle. During a flying trot both diagonal pairs may briefly leave the ground. The robot doesn't fall because it's continuously catching itself: the controller predicts where the body is going and places the next foot to redirect it. This is fast (the 3–6 m/s top speeds in the roster come from dynamic gaits) and it is hard.

Why you need 1 kHz torque loops

Dynamic balance is a race against gravity. A toppling body accelerates; the longer your control loop's period, the further it's fallen before you react, and the harder the correction. Concretely:

• The low-level joint torque loop runs at ~1 kHz (1 ms period). This is the loop that takes a desired joint torque and commands the FOC current controller. (The FOC current loop underneath it runs far faster, ~10–40 kHz.)
• The whole-body / MPC controller runs at ~100–500 Hz, recomputing desired contact forces and body trajectory.
• A footstep / gait planner runs at ~10–50 Hz, deciding where feet go.

Rule: if your joints can't accept new torque commands at 1 kHz with low latency, you cannot do robust dynamic locomotion. This is why legged robots use real-time control systems — deterministic timing on CAN/EtherCAT buses and an RTOS or PREEMPT_RT Linux. Jitter is the enemy; a 5 ms hiccup at the wrong moment is a fall.

The QDD actuator earns its keep here too: a clean, low-inertia, near-linear joint plant is controllable at 1 kHz. A high-ratio geared joint with backlash and sensor lag fights you at those rates.

Sensing for locomotion

A walking robot needs to answer two questions continuously: where is my body and how is it moving? (proprioception) and what does the ground ahead look like? (exteroception). The first keeps it upright; the second lets it choose footholds. See the robot sensors guide for the full sensor taxonomy.

The proprioceptive state estimate

This is the heart of staying upright, and it's almost entirely internal sensing:

• IMU (a 6-axis or 9-axis MEMS unit at the body) — gives angular rate and linear acceleration at high rate (hundreds of Hz to kHz). It's the fastest indicator of body orientation and motion, but it drifts when integrated.
• Joint encoders — one per actuated joint (and ideally a second at the output, as the QDD module provides). These give exact leg geometry, so via forward kinematics you know where each foot is relative to the body. See the encoders guide.
• Foot contact sensing — whether a foot is loaded. Some robots use explicit contact switches or foot force sensors; many QDD robots infer contact from joint torque (the foot pushing back shows up as torque you can read from current). Knowing which feet are stance feet is essential for the estimator.

These fuse in an extended Kalman filter (EKF) (or a factor-graph estimator) that combines IMU integration with leg-kinematic "velocity measurements": when a foot is firmly planted, the kinematics tell you the body's velocity relative to that fixed contact, which corrects the IMU drift. The output is a continuously updated estimate of body position, velocity, orientation, and angular rate at 500 Hz–1 kHz. No camera required to balance — and that's by design, because vision is too slow and too failure-prone to depend on for not falling over.

Exteroception for terrain

To choose where to step, the robot needs to see the ground ahead:

• Depth cameras (Intel RealSense-class stereo/active IR) on the body and pointing down-forward, building a local heightmap of the terrain.
• LiDAR (often a compact spinning or solid-state unit) for longer range, mapping, and SLAM. ANYmal and Spot lean on LiDAR for autonomous navigation and inspection mapping.
• Increasingly, learned terrain perception that turns raw depth into a traversability/heightmap the foothold planner consumes.

See the LiDAR & depth cameras guide for the sensing tradeoffs. The important architectural point: exteroception is advisory. The robot blends a perceived heightmap with proprioceptive feedback, and a good controller falls back gracefully to "blind" locomotion (feeling the terrain through the legs) when the camera is blinded by dust, glare, or fog. The best 2026 RL policies are explicitly trained to walk blind and use vision only to anticipate.

Balance & control: MPC, WBC, and RL

The control stack is where the field is moving fastest. Two broad lineages, increasingly blended.

Model-based: MPC and whole-body control

The classical, model-based approach reasons explicitly about physics:

• Model predictive control (MPC) treats the body as a (often simplified) rigid mass and predicts its motion over a short horizon (say 0.5–1 s), solving an optimization at each tick (~100–500 Hz) for the contact forces that keep it on a desired trajectory while respecting friction-cone constraints (feet can push, not pull, and can't slip). A common simplification is the single rigid body model with point-foot contacts.
• Whole-body control (WBC) takes MPC's desired body wrench and resolves it into joint torques across all 12 actuators, respecting the full robot dynamics and prioritized tasks (keep the body level, track the swing-foot trajectory, don't exceed torque limits).

This stack is interpretable, tunable, and what Boston Dynamics, ANYbotics, and most academic platforms ran for years. Its weakness is that it's only as good as the model, and modeling contact, compliance, and weird terrain is hard.

Learning-based: RL trained in sim

The dominant trend since roughly 2019–2022, pioneered heavily on ANYmal at ETH Zurich and now ubiquitous: train a neural-network control policy in massively parallel physics simulation (Isaac Gym / Isaac Lab and friends), then deploy it on the real robot.

The policy maps proprioceptive state (and optionally a terrain heightmap) directly to joint targets, at the same ~1 kHz the model-based stack uses. The appeal is robustness: you simulate thousands of robots across randomized terrain, friction, mass, and disturbances, and the policy learns to handle a distribution of conditions no hand-tuned controller could enumerate.

The sim-to-real story

The catch is the reality gap: a policy that's perfect in sim can fail on hardware because the simulator's contact, friction, actuator dynamics, and latency don't match reality. The techniques that close it:

• Domain randomization — randomize masses, friction, motor gains, latency, terrain so the policy can't overfit to one physics.
• Actuator-network modeling — learn a model of the real QDD actuator's torque response (including its quirks) and put that in the sim loop. This was a key ANYmal contribution.
• Teacher–student / privileged learning — train a "teacher" with full sim knowledge, then distill a "student" that uses only the sensors the real robot has.

Why QDD makes RL practical: the policy outputs torques (or joint targets the joint tracks with torque), and a transparent, near-linear QDD joint behaves enough like the simulated one that domain randomization can bridge the rest. The same RL trick is much harder on stiff, backlash-ridden, non-backdrivable joints whose real dynamics are nasty to model.

In 2026 the honest state of the art is hybrid: many production systems use RL for the locomotion controller (robust walking over bad terrain) and keep model-based planning for navigation and manipulation. The RL-everywhere vs model-based-everywhere debate is mostly settled in favor of "use both, at the layer each is good at."

Power & runtime

Legs are hungry, and the battery is heavy, and those two facts fight each other. See the robot power & batteries guide for the chemistry and pack-design details; here's what's specific to legs.

Where the energy goes

A walking quadruped spends energy on three things, roughly in this order:

1. Holding itself up. Because QDD joints aren't self-locking, standing and slow walking burns current on gravity compensation — the motors hold torque continuously. This is a big, often underappreciated chunk; a quadruped standing still still draws meaningful power (tens to a couple hundred watts depending on size).
2. Moving the legs. Accelerating leg masses every step (minimized by low distal inertia) and doing the positive work of propulsion.
3. Everything else — compute (a perception/autonomy stack can pull 50–150 W), sensors, comms, heaters/coolers.

The result is the 1–4 hour runtimes you see in the roster. A 15 kg Unitree Go2 might draw a few hundred watts walking; a 50 kg ANYmal or Spot draws considerably more. CoT of ~0.5 means that for every joule of "useful" gravitational-potential equivalent, you're spending several — most of it as heat in the motors and as standing overhead.

Crude runtime estimate:

  t_run ≈ (E_battery · DoD) / P_avg

  E_battery = pack energy        [Wh]
  DoD       = usable depth of discharge (~0.8 for Li-ion)
  P_avg     = average power draw  [W]

Example: a ~600 Wh pack, DoD 0.8, walking at P_avg ≈ 250 W:
  t_run ≈ (600 · 0.8) / 250 ≈ 1.9 h

Standing idle at P_avg ≈ 120 W:
  t_run ≈ (600 · 0.8) / 120 ≈ 4 h

Hot-swap and docking

For any real deployment, runtime alone doesn't decide uptime — recharge logistics do. Two answers:

• Hot-swappable battery packs (Spot, ANYmal, Unitree B2) — a field operator or a docking arm swaps a depleted pack for a charged one in under a minute, so the robot is down for seconds, not hours.
• Autonomous docking — the robot walks to a charging dock between patrols. For a security or inspection robot doing scheduled rounds, a 90-minute patrol followed by a dock charge is a perfectly workable duty cycle and is how most fleet deployments actually run.

The design tension is permanent: a bigger battery means longer runtime but more mass, which raises power draw (you're carrying it), which eats into the gain. There's a sweet spot, and most commercial quadrupeds have settled near the 1–2 hour mark with swap/dock as the real uptime strategy.

Bipeds vs quadrupeds

People assume two legs is the "advanced" version of four. Mechanically and control-wise it's the opposite: four legs is dramatically easier.

Why four is easier than two

• A quadruped can always have a stable base. During slow gaits it keeps three feet down — an instant stable tripod — and never has to balance on a single contact. A biped, mid-stride, is balancing the entire body on one foot, an inherently unstable inverted pendulum.
• The fall problem is gentler. A quadruped that loses balance often just plants a leg and recovers; a biped that loses balance falls from standing height onto expensive hardware.
• Wider support polygon, lower CoM. Quadrupeds are long and low; their center of mass sits inside a big support polygon. Bipeds are tall with a small base — far less margin.
• Less actuator stress per joint relative to stability. Four legs share the body weight and the work; redundancy means a quadruped can limp on three.

This is why quadrupeds matured years before humanoids. The actuator technology (QDD), the state estimation (IMU + leg kinematics EKF), the dynamic-gait control (MPC/WBC/RL) — all of it was proven on four legs first.

The bridge to humanoids

The quadruped is the humanoid's training ground. Nearly every component of a 2026 humanoid leg is inherited from quadruped work: the QDD or high-torque-density actuators, the proprioceptive torque control, the sim-trained RL locomotion policies, the contact-aware whole-body control. The hard new problems for bipeds — balancing on one foot, the much smaller stability margin, the coupling of locomotion with arm/manipulation dynamics — sit on top of a foundation that quadrupeds built. If you want the upright version of this story, see the humanoid robot hardware guide.

If you're learning legged robotics, start with quadrupeds. The physics is the same, the failures are cheaper, and almost everything transfers up to two legs.

Applications & honest ROI

Strip away the viral dancing-robot videos and the real money is in unglamorous, repetitive, hazardous-or-remote inspection. Here's the honest picture.

Where quadrupeds actually earn their keep

• Industrial inspection — substations, oil-and-gas facilities, chemical plants, power generation. A quadruped walks a fixed route, reads gauges (visually), images equipment with thermal and RGB, sniffs for gas, and logs acoustic anomalies — autonomously, on a schedule, in environments built for humans (stairs, catwalks, valve handles at human height). This is ANYmal's and Spot's bread and butter, and it's a real ROI story: the alternative is paying a technician to walk a hazardous route every shift.
• Mapping & survey — construction-site progress scans (a quadruped + LiDAR doing daily reality-capture), underground mine mapping where GPS is gone and the terrain is bad.
• Security & patrol — perimeter patrol, especially where the route includes stairs or rough ground that wheeled robots can't do. Ghost Robotics and others target this and defense.
• Research — by unit count, this is huge. Unitree's pricing put a real dynamic-locomotion platform in hundreds of labs, accelerating the whole field.
• Disaster response & nuclear — sending a $100k robot into a collapsed structure or a contaminated zone instead of a person.

The honest ROI caveat

Be skeptical of the breathless deployment numbers. The ROI works when all of these hold: the route genuinely needs legs (otherwise a cheaper wheeled AMR wins), the inspection is repetitive and frequent enough to amortize the robot, and the autonomy stack is mature enough to run without a babysitter. Many early "deployments" were really pilots with an operator standing nearby. The 2026 reality: inspection-route automation in a handful of heavy industries is genuinely paying off; general-purpose "robot dog does useful work around your facility" is still mostly aspirational.

Households are not a market yet. A consumer Unitree Go2 is a wonderful research/hobby/education platform and a delightful toy. It is not doing chores. The combination of cost, runtime, manipulation limits (a quadruped with no arm can't do much), and safety means the home quadruped is years from a real use case.

Building or selecting a legged robot

Off-the-shelf vs DIY

For almost everyone, buy, don't build. The QDD actuator, the FOC drive firmware, the state estimator, and the locomotion controller each represent years of specialized work. Unless your research is one of those layers, you'll get further faster on a commercial platform with an SDK.

That said, the DIY path is more open than it's ever been, thanks to the open-source ecosystem the MIT Cheetah work seeded:

• MIT Mini Cheetah / Open Dynamic Robot Initiative (ODRI) — open hardware designs for QDD legs.
• MJBots (qdd100 actuators, moteus FOC controllers) — buy modules, build your own quadruped.
• Stanford Doggo / Pupper — educational open-source quadrupeds at the low end.
• T-Motor AK-series / CubeMars — affordable QDD-style actuator modules for builders.

Building your own teaches you the stack like nothing else, and a basic trot is achievable for a determined team. Matching a commercial platform's robustness, autonomy, and terrain capability is a multi-year program — respect that gap.

The cost curve and Unitree's disruption

Tier	Example	Indicative cost	What you get
Hobby / education	Stanford Pupper, Petoi	~$500–$2,000	Learn the basics; limited dynamics
DIY QDD build	MJBots / ODRI parts	~$3,000–$10,000	Real dynamic legs; you write the stack
Consumer-research	Unitree Go2 (base→EDU)	~$1,600–$16,000	Capable QDD quadruped + SDK
Mid industrial	DEEP Robotics X30, Unitree B2	~$50,000–$100,000	Rugged, real payload, autonomy
Premium industrial	Spot, ANYmal, Vision 60	~$75,000–$150,000+	Ecosystem, support, IP-rated, deployments

The single biggest market event of the last few years was Unitree collapsing the price floor. A research-grade dynamic quadruped cost ~$75,000 in 2019 (Spot's launch price). By 2024 a Unitree Go2 base unit (the Go2 Air) was ~$1,600 — a >40× drop. That did to legged-robot research what the Raspberry Pi did to embedded computing: it put real hardware in the hands of anyone with a modest budget and accelerated the entire field, while also detonating a competitive and geopolitical scramble over who supplies the world's robot dogs.

A selection checklist

Choosing a quadruped, in order of what actually matters:

1. Does the terrain truly require legs? If not, stop and buy a wheeled AMR.
2. Payload and sensor integration — can it carry your inspection package, and does it expose a clean power/data interface?
3. SDK and autonomy maturity — can it run your mission without a human driver? This is where Spot/ANYmal justify their price.
4. Support, sealing (IP rating), and field serviceability — industrial deployment lives and dies here.
5. Runtime + recharge logistics — hot-swap or dock, matched to your duty cycle.
6. Data governance & procurement constraints — for industrial/government buyers, where the robot (and its data pipeline) comes from is sometimes the deciding factor regardless of specs.

Frequently asked questions

Why do legged robots use brushless motors instead of regular servos or stepper motors?

Because dynamic legs need torque-controllable, backdrivable, high-power-density actuators, and a brushless DC motor run with field-oriented control delivers exactly that — you command torque directly via current, and a low gear ratio keeps the joint backdrivable. Hobby servos are position-only and not backdrivable; steppers are heavy for their torque and run open-loop. See the BLDC and robot actuators guides.

What does "quasi-direct-drive" actually mean?

A true direct drive has no gearbox — the motor drives the joint directly. That gives perfect transparency but needs an enormous motor for useful torque. Quasi-direct-drive adds a small gear reduction (about 6:1 to 10:1) to get usable torque while keeping most of the transparency and backdrivability. It's the pragmatic middle ground, and it's what nearly every modern legged robot uses.

Why is the standard quadruped leg 3 degrees of freedom?

Three actuated joints (hip roll, hip pitch, knee pitch) are the minimum needed to place the foot anywhere in a 3D workspace and still control the body's roll, pitch, and height. Two DoF restricts the leg to a plane and gives up lateral balance; more than three adds weight and complexity for little locomotion benefit on a point-foot leg.

Can a quadruped really balance without cameras?

Yes — and it should. Balance is maintained from proprioception: an IMU plus joint encoders plus foot-contact information, fused in a Kalman filter to estimate body velocity and orientation at ~1 kHz. Cameras and LiDAR are for choosing footholds and navigating, not for staying upright. Good controllers walk "blind" and treat vision as anticipation.

Why do these robots need 1 kHz control loops?

Dynamic gaits leave the robot statically unstable, so it stays up by continuously catching itself. The longer the control period, the further the body falls before correction, and the harder (or impossible) the recovery. A ~1 kHz joint torque loop with low, deterministic latency is the practical floor for robust dynamic locomotion — which is why these robots run real-time control systems. See the real-time control guide.

How long do quadruped robots run on a charge?

Typically 1–4 hours depending on size, gait, and payload. A small Unitree Go2 might get 1–2 hours; a larger ANYmal or Spot is similar despite a bigger battery because it's heavier and draws more power. Real-world uptime comes from hot-swappable batteries or autonomous docking, not from raw runtime.

Is reinforcement learning replacing model-based control for legged robots?

Partly, and as a complement rather than a clean replacement. RL policies trained in massively parallel simulation (with domain randomization and learned actuator models to bridge the sim-to-real gap) now drive locomotion on many platforms because they're robust to terrain and disturbances. Model-based MPC/WBC remains common, and most production stacks in 2026 use RL for walking and model-based methods for higher-level planning and manipulation.

Why is a quadruped easier to control than a humanoid?

A quadruped can keep three feet on the ground for a stable tripod and never has to balance on a single contact, has a wide support polygon and low center of mass, and recovers from disturbances by planting a leg. A biped is a tall inverted pendulum balancing on one foot for half of every stride. Four legs proved the actuators and control that humanoids now inherit — see the humanoid hardware guide.

What's the cheapest way to get a real dynamic quadruped?

A Unitree Go2 base unit (the Go2 Air, ~$1,600) is the cheapest capable, dynamics-ready platform with an SDK. If you want to build, MJBots qdd100 actuators with moteus controllers, or the open ODRI/Mini Cheetah designs, get you a real QDD quadruped for roughly $3,000–$10,000 in parts — plus the considerable effort of writing the control stack yourself.

Why not just use wheels with suspension instead of legs?

For most terrain, you should — wheeled and wheel-legged hybrids are more efficient and reliable. Legs only win when the terrain has discrete obstacles (stairs, gaps, large steps) that a wheel fundamentally cannot roll over. The smart middle ground is wheeled legs (wheels on articulated legs) that roll on flat ground and walk only when forced to, recovering much of the energy-efficiency gap. See the mobile robots guide.

Do quadrupeds need force sensors in their feet?

Usually not. With QDD actuators you estimate joint torque from motor current, and the leg Jacobian maps that to foot force — so you get foot-force sensing "for free" without a load cell. Some robots add explicit contact switches or foot sensors for robustness, but the proprioceptive estimate is what most dynamic controllers actually use.

What gear ratio should a leg actuator use?

Roughly 6:1 to 10:1, single-stage planetary. Below ~6:1 you need an impractically large motor for the torque; above ~10:1 you start losing backdrivability and gaining reflected inertia (which scales with the square of the ratio), pushing you back toward the stiff geared-arm regime that's wrong for legs. See the gearboxes guide.