Skip to content

Stabilarity Hub

Menu
  • Home
  • Research
    • Healthcare & Life Sciences
      • Medical ML Diagnosis
    • Enterprise & Economics
      • AI Economics
      • Cost-Effective AI
      • Spec-Driven AI
    • Geopolitics & Strategy
      • Anticipatory Intelligence
      • Future of AI
      • Geopolitical Risk Intelligence
    • AI & Future Signals
      • Capability–Adoption Gap
      • AI Observability
      • AI Intelligence Architecture
      • AI Memory
      • Trusted Open Source
    • Data Science & Methods
      • HPF-P Framework
      • Intellectual Data Analysis
      • Reference Evaluation
    • Publications
      • External Publications
    • Robotics & Engineering
      • Open Humanoid
      • Open Starship
      • Living NPCs
    • Benchmarks & Measurement
      • Universal Intelligence Benchmark
      • Shadow Economy Dynamics
      • Article Quality Science
  • Tools
    • Healthcare & Life Sciences
      • ScanLab
      • AI Data Readiness Assessment
    • Enterprise Strategy
      • AI Use Case Classifier
      • ROI Calculator
      • Risk Calculator
      • Reference Trust Analyzer
    • Portfolio & Analytics
      • HPF Portfolio Optimizer
      • Adoption Gap Monitor
      • Data Mining Method Selector
    • Geopolitics & Prediction
      • War Prediction Model
      • Ukraine Crisis Prediction
      • Gap Analyzer
      • Geopolitical Stability Dashboard
    • Technical & Observability
      • OTel AI Inspector
    • Robotics & Engineering
      • Humanoid Simulation
      • Living Village (AI NPC game)
      • Wizard Village (AI NPC 3D game)
    • Benchmarks
      • UIB Benchmark Tool
    • Article Evaluator
    • API Gateway
  • EKIT Department
  • About
    • Contributors
  • Contact
  • Join Community
  • Terms of Service
  • Login
  • Register
Menu

7 Open Source Humanoid Robots Pushed in Simulation: Feet Beat Torque

Posted on November 16, 2026November 16, 2026 by
Future of AIJournal Commentary · Article 29 of 29
By Oleh Ivchenko

7 Open Source Humanoid Robots Pushed in Simulation: Feet Beat Torque

Academic Citation: Ivchenko, Oleh (2026). 7 Open Source Humanoid Robots Pushed in Simulation: Feet Beat Torque. Research article: 7 Open Source Humanoid Robots Pushed in Simulation: Feet Beat Torque. Odessa National Polytechnic University, Department of Economic Cybernetics.
DOI: 10.5281/zenodo.24294912[1]  ·  View on Zenodo (CERN)
DOI: 10.5281/zenodo.24294912[1]Zenodo ArchiveSource Code & DataCharts (4)ORCID
4,110 words · 70% fresh refs · 3 diagrams · 27 references

89stabilfr·wuedophcgmx
BadgeMetricValueStatusDescription
[s]Reviewed Sources19%○≥80% from editorially reviewed sources
[t]Trusted100%✓≥80% from verified, high-quality sources
[a]DOI81%✓≥80% have a Digital Object Identifier
[b]CrossRef19%○≥80% indexed in CrossRef
[i]Indexed81%✓≥80% have metadata indexed
[l]Academic85%✓≥80% from journals/conferences/preprints
[f]Free Access100%✓≥80% are freely accessible
[r]References27 refs✓Minimum 10 references required
[w]Words [REQ]4,110✓Minimum 1,000 words of article body. Current: 4,110
[u]Original [REQ]100%✓≥85% unique sentences (no padding or repeated blocks) and no leaked drafting notes. Current: 100% unique
[e]Evidence [REQ]22✓Cites at least 1 external source(s): links, DOIs or a reference list. Current: 22
[d]DOI [REQ]✓✓Zenodo DOI registered for persistent citation. DOI: 10.5281/zenodo.24294912
[o]ORCID✓✓Author ORCID verified for academic identity
[p]Peer Reviewed—○Peer reviewed by an assigned reviewer
[h]Freshness70%✓≥60% of references from 2025–2026. Current: 70%
[c]Data Charts4✓Original data charts from reproducible analysis (min 2). Current: 4
[g]Code✓✓Source code available on GitHub
[m]Diagrams3✓Mermaid architecture/flow diagrams. Current: 3
[x]Cited by0○Referenced by 0 other hub article(s)
Score = Ref Trust (86 × 60%) + Required (4/4 × 30%) + Optional (5/7 × 10%)

Abstract #

Picking an open source humanoid robot platform for simulation work usually starts with a spec sheet: degrees of freedom (DoF), mass and joint torque. We tested whether those numbers say anything about how the models behave. Seven open humanoid models from MuJoCo Menagerie went through the same tests: Unitree G1, Unitree H1, Booster T1, Fourier N1, Apptronik Apollo, PAL TALOS and the Berkeley Humanoid. We read a spec sheet out of each MJCF file and timed each model on one CPU core. Then every robot held its posture under one identical joint PD rule while we searched, by bisection, for the smallest 0.1 s shove at the pelvis that knocks it over. All seven stand for 10 s under that rule. Their weakest-direction toppling push spans 0.2413 m/s of whole-body velocity change (H1) to 0.4156 m/s (N1). Torque per kilogram does not predict that ranking (Pearson r = -0.297 across seven models), and neither does mass (r = 0.007). A one-line capture-point bound built only from foot size and centre-of-mass (CoM) height does: r = 0.917 over 21 robot-direction pairs, with measured values between 0.79 and 1.22 times the bound. Simulation speed differs by 2.76 times, from 15,926 steps/s (TALOS) to 43,879 steps/s (Berkeley Humanoid), and tracks DoF closely (r = -0.972). Four models are Apache-2.0 and three are BSD-3-Clause. The licences cover the simulation description, not the hardware.

1. Introduction #

Our previous article in this series loaded five open humanoid models and asked how long each could hold a box before a motor overheated [1][2]. That was a question about one task. This article steps back and puts seven open models side by side on the questions people ask before they choose one: what exactly is open, how the robots compare physically, how fast they simulate, and how hard they are to knock over. It extends the hub’s broader engineering series on building an open humanoid [2].

The seven models come from MuJoCo Menagerie, a curated collection of robot models for the MuJoCo physics engine [3][3][4][4]. They range from a 16.06 kg research biped to a 94.0 kg industrial humanoid. All seven are free to download and run, which makes them a de facto “open humanoid” shortlist, even though none of the robots can be built from the files.

What is missing is a like-for-like comparison. Vendors publish different numbers in different units. Papers report results on one robot with one tuned controller. A newcomer cannot tell from those sources whether the G1 is “more stable” than the T1 or whether a high torque-to-weight ratio buys anything when the robot is pushed. We hold everything constant that we can: one physics engine, one timestep, one contact model, one controller rule, one push protocol.

RQ1: What do the seven open humanoid models actually release, and how do they compare on DoF, mass and torque-to-weight when every number is read from the MJCF files? RQ2: How fast does each model simulate on one CPU core, and what drives the differences? RQ3: Under one identical PD posture hold, what is the smallest push that topples each model, and does any spec-sheet number predict it?

2. Existing Approaches (2025-2026 state of the art) #

2.1 Open humanoid hardware #

The open source humanoid robot platform movement has split into two groups. One group releases complete hardware. Berkeley Humanoid Lite is a 3D-printed robot with cycloidal gearboxes, priced under $5,000 in parts, with hardware, embedded code and training code all released [5][5]. ToddlerBot is a 0.56 m, 3.4 kg robot that costs under 6,000 USD and has been independently replicated [6][6]. AGILOped is 110 cm tall, weighs 14.5 kg and uses off-the-shelf backdrivable actuators [7][7]. PhoneBot uses a smartphone for sensing and computing and 13 low-cost actuators for its lower body [8][8]. These designs give full access, but they are small robots with low payload.

The second group, the subject of this article, releases a simulation description of a robot that is otherwise closed or sold commercially. The MJCF file gives kinematics, masses, inertias, joint ranges and actuator limits, which is everything a controller needs in simulation. It does not include the motor drivers, the firmware or the vendor’s walking controller.

2.2 Simulation-first humanoid development #

Most humanoid control work now starts in simulation. MuJoCo Playground, built on the same engine and model collection, trains policies “in minutes on a single GPU” and reports zero-shot transfer to real robots, humanoids among them [9][9]. FastSAC and FastTD3 train locomotion for the G1 and T1 in 15 minutes on one RTX 4090, with push perturbations among the randomised conditions [10][10]. A 2025 survey of humanoid locomotion and manipulation frames the field as a trade-off between model fidelity and computational efficiency [11][11]. Simulation speed per model therefore matters, but it is rarely reported per robot. GPU throughput figures hide the per-model cost that matters for model-based control, debugging and CPU-only continuous integration.

2.3 Push recovery and the capture point #

Push recovery theory names three strategies: shift the centre of pressure under the feet (ankle strategy), swing the upper body (hip strategy), or take a step [12][12]. The capture point is the point on the ground where the robot must place its centre of pressure to come to rest. For a linear inverted pendulum it lies ahead of the CoM by velocity divided by sqrt(g/h) [13][13]. Capturability analysis turns this into limits on what pushes a robot can absorb with or without stepping [14][14]. Recent work builds on it. One controller braces the arms against walls and recovers from 100 N, 0.2 s pushes while walking at up to 0.5 m/s in simulation [15][15]. HuB trains the G1 for extreme single-leg poses that stay upright under strong disturbances [16][16]. A 2026 study shows that capture-point information can be computed from joint encoders and an IMU alone. Its policy held a clean single-leg stance on 89 of 90 held-out motions on a G1, while eight released general policies managed none [17][17].

2.4 Robot-specific platform papers #

Several of the seven models have their own papers. The Berkeley Humanoid was designed for “low simulation complexity” and a narrow sim-to-real gap [18][18]. Booster Gym provides a training-to-deployment framework validated on the T1, including disturbance resistance [19][19]. TALOS was introduced as an industrial research humanoid that can handle 6 kg with an outstretched arm and has torque sensors in its joints [20][20]. Each paper uses its own controller and protocol, so their robustness claims cannot be compared directly.

flowchart TD
    Q[Choosing an open humanoid] --> A[Open hardware: full design released]
    Q --> B[Open model: simulation description only]
    A --> A1[Small, low cost, replicable]
    B --> B1[Commercial or lab robots, MJCF in Menagerie]
    B1 --> C[Spec sheet: DoF, mass, torque limits]
    B1 --> D[Simulation speed per model]
    B1 --> E[Robustness under one controller]
    C --> G[Gap: no like-for-like comparison]
    D --> G
    E --> G

3. Method and Data #

3.1 Models and what we kept #

All seven models come from Menagerie commit 98a70c569c4c1b6da467a20012f766ee1f8dc521 [3][3], run in MuJoCo 3.17.0. For the TALOS we used the torque-motor variant. Mesh files were not downloaded. Every body in all seven models has explicit inertia, so masses and inertias do not depend on the meshes, and we removed mesh geoms. One exception needed a fix: the Fourier N1 collides with the floor through two foot meshes, which we replaced with boxes fitted to the meshes’ bounding box (0.214 m by 0.077 m). Mesh counts and sizes come from the repository listing at the same commit.

3.2 Spec sheet #

DoF is the number of joint velocities minus the six of the floating base. Torque limits are the actuator force limits the simulator enforces. As in our previous article, these do not always match vendor brochures [1][2]. We report the sum of all limits per kilogram, and the knee and ankle limits divided by body weight. The second figure is a lever arm in centimetres: the distance from the joint at which the robot’s full weight would saturate it.

3.3 One controller for everyone #

Every actuated joint gets a position servo whose stiffness is set by the same rule: kp = tau_max / 0.05 rad, so a joint reaches its torque limit at 0.05 rad (2.9 degrees) of error. Damping is kv = 0.03 s times kp, and torque is clipped at the joint’s limit. The posture is each model’s Menagerie keyframe. We rotate the body so the soles are flat and offset both ankle pitch joints so the whole-body CoM sits over the centre of the support area. The offsets range from -0.0724 rad (H1) to 0.0464 rad (Apollo). Settings are identical for all robots: a 2 ms timestep, the implicitfast integrator, a Newton solver with 100 iterations, and robot-floor contacts only, with each model’s own friction and contact stiffness.

This controller does no balancing in any active sense. It has no IMU feedback, no CoM estimate, no stepping and no arm motion. It is a stiff, torque-limited posture hold. The push test therefore measures passive-ish robustness under identical PD, not what the real robots or their vendor controllers can recover from.

3.4 Tests #

  • Standing: 10 s; a fall is the CoM dropping below 70% of its starting height.
  • Push: 1 s of settling, then a 0.1 s horizontal force at the root body (pelvis or trunk) forward, backward or sideways, then 3.9 s of observation. We bisect, over 12 iterations between 0 and 3 m/s, on the velocity change the push imparts to the whole body, Δv = F × 0.1 s / m. The unit is N·s per kg, so a 16 kg and a 94 kg robot are compared fairly. A spot check confirmed monotonic behaviour: every model survives 0.8 and 0.95 times its forward threshold and falls at 1.05, 1.5, 2 and 4 times.
  • Capture-point bound: Δv_bound = (distance from CoM to support edge) × sqrt(g / CoM height). This is the largest velocity a linear inverted pendulum can absorb with its centre of pressure at the edge of the feet [13][13][14][14].
  • Speed: five runs of 5,000 steps from the standing state on one thread; we report the median.
  • Sensitivity: the forward push is repeated with joints saturating at 0.025, 0.1 and 0.2 rad (twice as stiff, half and a quarter as stiff).
flowchart LR
    M[Menagerie MJCF, 7 robots] --> S[Spec sheet from the files]
    M --> P[Flat feet, CoM over support centre]
    P --> K[Identical PD: kp = tau_max / 0.05 rad]
    K --> T[10 s stand test]
    K --> V[Speed: 5 x 5000 steps]
    K --> B[Push bisection, 3 directions]
    B --> C[Compare with capture-point bound]
    B --> G[Gain sweep 0.025 to 0.2 rad]

The whole run takes 73.0 s on one core of an AMD EPYC virtual machine. Code, models, results and charts: stabilarity/hub/research/open-source-humanoid-robot-simulation.

4. Results #

4.1 RQ1: What makes an open source humanoid robot platform open, and how the models compare #

Licences. Four models (Booster T1, Fourier N1, Apptronik Apollo, PAL TALOS) ship under Apache-2.0, and three (Unitree G1, Unitree H1, Berkeley Humanoid) under BSD-3-Clause. Both are permissive and allow commercial use and modification. They differ in two ways that matter to companies. The Apache-2.0 text in the four files includes an explicit patent licence (section 3), which the BSD text lacks. The BSD-3-Clause text forbids using the copyright holder’s name to endorse derived products, which matters if a product is marketed as “based on” a named robot. In all seven cases the licence covers the description files: kinematics, inertias, limits and meshes. It does not cover hardware designs, firmware or controllers. The models also differ in provenance. Five Menagerie READMEs name a public URDF or MJCF source, the H1’s says Unitree provided the files directly, and Apollo’s names no upstream source.

Humanoid robot dynamics: mass, DoF and torque-to-weight. Chart 1 and the table below summarise what the files contain.

Left: scatter of model mass against the sum of actuator torque limits for seven open humanoids, with marker size proportional to degrees of freedom; Apptronik Apollo has the highest total torque at about 5000 newton metres, Berkeley Humanoid the lowest at 250. Right: bars of torque per kilogram, from 61.26 for Apollo to 15.57 for Berkeley Humanoid, and knee torque divided by body weight in centimetres

RobotLicenceDoF (actuated)Mass (kg)Sum of torque limits (N·m)Torque per kg (N·m/kg)Knee limit (N·m)Ankle pitch limit (N·m)Knee lever (cm)Meshes (files, MB)
Unitree G1BSD-3-Clause29 (29)33.341566.046.97139.050.042.551, 35.95
Unitree H1BSD-3-Clause19 (19)51.442312.044.95300.040.059.4521, 14.32
Booster T1Apache-2.023 (23)31.61588.018.660.020.019.3524, 8.43
Fourier N1Apache-2.023 (23)39.731118.028.1495.030.024.3829, 63.46
Apptronik ApolloApache-2.032 (32)80.94956.061.26336.0150.042.3444, 71.21
PAL TALOSApache-2.044 (32)94.03326.035.38400.0160.043.3849, 7.95
Berkeley HumanoidBSD-3-Clause12 (12)16.06250.015.5730.020.019.0513, 27.2

Source: our extraction from the MJCF files of MuJoCo Menagerie [3][3]. Knee lever = knee torque limit / (mass × g). Mesh sizes from the repository listing at the same commit.

The spread is wide. Apollo has nearly four times the torque per kilogram of the Berkeley Humanoid (61.26 against 15.57 N·m/kg). The G1 and H1 sit close together at 46.97 and 44.95 N·m/kg, but they spend that budget differently. The H1 has the strongest knee relative to its weight (a 59.45 cm lever) and one of the weakest ankles (40.0 N·m for 51.44 kg, a 7.93 cm lever). The TALOS has 44 DoF, but 12 of them are unactuated gripper finger joints; it has the same number of actuated joints as Apollo, 32. The Berkeley Humanoid is legs only, with 12 DoF. The G1’s MJCF files are the largest description at 116,575 bytes, more than seven times the H1’s 15,692 bytes. Mesh payloads range from 7.95 MB (TALOS) to 71.21 MB (Apollo), and the simulation does not need any of them.

4.2 RQ2: Humanoid robot simulation speed on a CPU #

Under identical settings, the Berkeley Humanoid runs at 43,879 steps/s, or 87.76 times real time on one core. The TALOS is slowest at 15,926 steps/s, 31.85 times real time: a factor of 2.76 (Chart 2). Speed tracks DoF almost linearly in this sample (r = -0.972). It also tracks the number of constraint rows the solver handles each step (r = -0.814): 90.07 for the TALOS against 32.0 for the H1, whose feet are thin capsules. Every model runs at least 30 times faster than real time on a single core of a modest virtual machine. CPU speed is not what limits single-robot experiments with any of these models. It matters only when thousands of rollouts are needed, which is why GPU training frameworks exist [9][9][10][10].

Horizontal bars of real-time factor on one CPU core for seven humanoid models under uniform settings and under the native Menagerie settings; Berkeley Humanoid is fastest at 87.8 times real time, PAL TALOS slowest at 31.9; under native settings Apollo reaches 101.5 times because of its 5 millisecond step and TALOS falls to 13.9 times because of its 1 millisecond step

The settings shipped with each model change the picture more than the robot does. Apollo’s Menagerie scene uses a 5 ms step and 4 solver iterations, which gives 101.52 times real time, the fastest of all. The TALOS ships with a 1 ms step and drops to 13.9 times real time. A more than seven-fold gap between those two comes from configuration files, not physics. If you benchmark two open humanoids, set the timestep and solver yourself before you compare.

4.3 RQ3: Push test: which open humanoid stays upright #

All seven models stand for 10 s under the identical PD rule. The largest root tilt during that time is 1.68 degrees (N1), and the largest CoM drift is 0.0142 m (Apollo). Pushes are a different matter.

Grouped horizontal bars of the smallest toppling push for seven humanoids in forward, backward and lateral directions, expressed as whole-body velocity change in metres per second; Fourier N1 is most robust forward at 0.416, Unitree H1 least robust forward at 0.241, and lateral thresholds range from 0.513 for TALOS to 0.744 for H1

RobotForward Δv (m/s)Backward Δv (m/s)Lateral Δv (m/s)Forward peak force (N, 0.1 s)Capture-point bound, forward (m/s)Real-time factor, uniform
Fourier N10.41560.51160.6815165.10.419462.22
Booster T10.36150.36510.5834114.30.457667.69
Apptronik Apollo0.34310.37680.7006277.60.341845.0
PAL TALOS0.34390.33870.5131323.20.322731.85
Berkeley Humanoid0.31380.31530.587850.40.381987.76
Unitree G10.31160.36880.6588103.90.3246.84
Unitree H10.24130.2860.7438124.10.281275.36

Source: our MuJoCo simulations, identical PD posture hold (kp = tau_max / 0.05 rad), 0.1 s push at the root body. Rows sorted by weakest-direction threshold. Δv is impulse per kilogram.

The Fourier N1 is the hardest to topple. Its weakest direction is forward, at 0.4156 m/s. The Unitree H1 is the easiest, at 0.2413 m/s forward. In absolute terms the H1 falls from a 124.1 N push lasting 0.1 s, and the Berkeley Humanoid from 50.4 N. Every robot resists sideways pushes better than forward ones (0.5131 to 0.7438 m/s laterally, against 0.2413 to 0.4156 m/s forward), because a two-foot stance is wider than it is long. The H1’s lateral threshold is the highest of all (0.7438 m/s), thanks to its 0.4657 m wide stance, even though it is the weakest robot front to back.

What predicts the ranking. Torque does not. Across the seven robots, the weakest-direction threshold correlates at r = -0.297 with torque per kilogram, -0.678 with knee lever, -0.076 with ankle lever and 0.007 with mass. The robot with the most torque per kilogram (Apollo) ranks third, and the one with the least (Berkeley Humanoid) ranks fifth. Foot geometry does predict it. The capture-point bound uses only the distance from the CoM to the edge of the feet and the CoM height, and it matches the measured threshold with r = 0.917 over all 21 robot-direction pairs (Chart 4, right). The measured values range from 0.79 to 1.22 times the bound. The N1 wins because its feet extend 0.107 m in front of and behind its CoM, which sits 0.6384 m high. The H1 loses because its CoM is the highest of the seven (0.9496 m) and its foot margin is only 0.0875 m.

Left: forward toppling push against PD saturation angle from 0.025 to 0.2 radians for seven humanoids; most models lose robustness as gains soften, Unitree H1 cannot stand at 0.1 radians and Fourier N1 cannot stand at 0.2. Right: scatter of measured toppling push against the capture-point bound for 21 robot-direction pairs, lying close to the diagonal with Pearson r of 0.92

Where measured values exceed the bound, as for the G1 backward (1.153) and the N1 backward (1.22), the robot also uses something the pendulum lacks: its body rotates and its joints flex, which acts like a small hip strategy [12][12]. Where they fall short, as for the T1 (0.79) and the Berkeley Humanoid (0.822), the stiff servo does not move the centre of pressure all the way to the edge of the sole before the foot starts to tip.

Sensitivity to gains. The controller does matter, and Chart 4 (left) shows how much. With joints twice as soft (saturating at 0.1 rad), the H1 can no longer stand at all. Its 40.0 N·m ankle limit gives it the softest ankle relative to its weight and height. With joints four times as soft (0.2 rad), the N1 also falls without a push, and the T1’s forward threshold drops from 0.3615 to 0.0568 m/s. The TALOS (0.3439 to 0.2985 m/s) and the Berkeley Humanoid (0.3138 to 0.2919 m/s) are the least sensitive. Their ankle limits are large relative to weight and CoM height. Under our rule, ankle stiffness divided by gravitational stiffness is 7.367 and 11.735 for these two, against 3.339 for the H1. Torque limits therefore do matter, but as a condition for standing, not as a predictor of push robustness. Once a robot can hold its posture stiffly, its feet set the ceiling.

5. Discussion #

5.1 Choosing an open humanoid for your project #

The results point to a simple procedure. Check the licence and provenance first. Then decide what the simulation is for. Look at foot size and CoM height before torque.

flowchart TD
    S[What is the model for?] --> L{Need a patent grant or plan to ship a product?}
    L -->|Yes| A[Prefer Apache-2.0: T1, N1, Apollo, TALOS]
    L -->|No| B[BSD-3-Clause also fine: G1, H1, Berkeley]
    S --> R{Fast CPU iteration, legs only?}
    R -->|Yes| BH[Berkeley Humanoid: 12 DoF, 87.76x real time]
    R -->|No| W{Whole-body manipulation?}
    W -->|Yes| WB[G1, Apollo or TALOS: 29 to 32 actuated joints]
    W -->|No| P{Robust standing with simple control?}
    P -->|Yes| N[Fourier N1 or Booster T1: long feet, low CoM]
    P -->|No| H[H1: tall, strong knees, weak ankles in the model]

Three practical points follow. First, an open model is not an open robot. All seven licences cover the description files only. Teams that need to modify hardware should look at the fully open designs in Section 2.1 [5][5][6][6]. Second, benchmark speed with your own settings. Shipped timesteps differ by a factor of five (1 ms to 5 ms), and that changes speed more than the choice of robot does. Third, if your controller is simple, for example a model-based balance controller under development or a teleoperation baseline, the robot’s feet will set the margin you get. The capture-point bound can be computed from the MJCF in seconds and predicted our measured thresholds to within the range 0.79 to 1.22 times.

These results do not rank how good the robots are. The vendors’ learned controllers step, swing their arms and use IMU feedback. Published controllers recover from pushes far beyond our numbers [15][15][16][16][19][19]. Our test removes those skills on purpose, so that the remaining difference comes from the body.

5.2 Limitations and threats to validity #

  • Controller. A torque-limited joint PD is not any vendor’s controller. Our push numbers are passive-ish robustness under identical PD, not real-robot capability. They are lower bounds on what an active balance controller could do with the same body.
  • Gain rule. Scaling stiffness by each joint’s torque limit is one defensible rule among several. Chart 4 shows that it can change the ranking at soft gains. At the two stiffest settings the forward ranking keeps the same top (N1) and bottom (H1) robots.
  • Model fidelity. MJCF torque limits are what the simulator enforces, not certified actuator ratings, and collision geometry is the primitive geometry in the files. We replaced the N1’s foot meshes with fitted boxes. Simulation-to-reality gaps in joint torque are a known issue, and recent work injects torque perturbations during training to cover them [21][21].
  • Posture. We started each robot from its Menagerie keyframe, flattened its feet and centred its CoM. A different stance width or knee bend changes the capture-point bound, and therefore the threshold.
  • Push definition. A single 0.1 s pulse at the root body. Longer pushes, pushes at the shoulder and repeated pushes were not tested. Falls were judged by CoM height. We did not model the fall itself, which a recent line of work treats as its own control problem [22][22][23][23].
  • Speed. Measured on a shared virtual machine, where repeated runs vary by about 10%. GPU throughput is a different question; simulator choice and hardware requirements are surveyed elsewhere [24][24].
  • Sample size. Seven robots. Correlations over seven points are indicative; the 21-point capture-point comparison is stronger, but its points are not independent across directions of the same robot.

5.3 What would change the conclusion #

Three results would overturn our main claim that feet beat torque. One would be a stiffer or smarter controller under which the ranking follows torque per kilogram instead of the capture-point bound. Another would be a hardware push test on two of these robots with the order reversed from ours. The third would be vendor MJCF updates with substantially different foot geometry or ankle limits. The H1 result is the most fragile. Our previous article found that its MJCF ankle limit is below the figure on Unitree’s own product page [1][2], and a stronger ankle would let it stand at softer gains.

6. Conclusion #

RQ1 Finding: The seven open humanoid models release simulation descriptions under permissive licences (four Apache-2.0, three BSD-3-Clause) and differ about fourfold in torque per kilogram. Measured by the sum of MJCF torque limits divided by mass, Apollo leads at 61.26 N·m/kg and the Berkeley Humanoid trails at 15.57 N·m/kg; DoF ranges from 12 to 44. This matters for the series because an open humanoid model gives a controller everything it needs in simulation but nothing about the hardware, firmware or vendor controller.

RQ2 Finding: Under our uniform settings every model simulates at least 30 times faster than real time on one CPU core, and speed falls with DoF. Measured by steps per second under identical settings, the Berkeley Humanoid reaches 43,879 (87.76 times real time) and the TALOS 15,926 (31.85 times), a factor of 2.76, with r = -0.972 against DoF. Shipped timesteps move these numbers more than the robot does (TALOS 13.9 times and Apollo 101.52 times real time with native settings). This matters for the series because simulation cost is rarely the bottleneck for single-robot work, and benchmarks that use default settings mostly compare configuration files.

RQ3 Finding: Under one identical PD posture hold, foot geometry and CoM height, not torque, decide how hard an open humanoid is to topple. Measured by the smallest 0.1 s push that topples it, thresholds range from 0.2413 m/s (H1) to 0.4156 m/s (N1). They correlate with a capture-point bound at r = 0.917 over 21 robot-direction pairs, and with torque per kilogram at only r = -0.297. This matters for the series because the cheapest stability gain for a humanoid design is a longer foot or a lower CoM, and a bound computable from the MJCF predicts the result before any simulation runs.

The next question is whether the ranking survives a real balance controller: the same seven models, one shared learned policy architecture, and the same push protocol.

References (24) #

  1. Stabilarity Research Hub. (2026). 7 Open Source Humanoid Robots Pushed in Simulation: Feet Beat Torque. doi.org. dtl
  2. Stabilarity Research Hub. How Long Can a Humanoid Robot Hold a Box? Joint Torque, Motor Heat and Battery Limits on Five Open Robot Models. tb
  3. google-deepmind. google-deepmind/mujoco_menagerie (GitHub repository). github.com. tr
  4. Todorov, Emanuel; Erez, Tom; Tassa, Yuval. (2012). MuJoCo: A physics engine for model-based control. doi.org. dcrtil
  5. Chi, Yufeng, Liao, Qiayuan, Long, Junfeng, Huang, Xiaoyu, et al.. (2025). Demonstrating Berkeley Humanoid Lite: An Open-source, Accessible, and Customizable 3D-printed Humanoid Robot. doi.org. dtil
  6. Shi, Haochen, Wang, Weizhuo, Song, Shuran, Liu, C. Karen. (2025). ToddlerBot: Open-Source ML-Compatible Humanoid Platform for Loco-Manipulation. doi.org. dtil
  7. Ficht, Grzegorz, Denninger, Luis, Behnke, Sven. (2025). AGILOped: Agile Open-Source Humanoid Robot for Research. doi.org. dtil
  8. Hou, Ruochen, Wang, Quanyou, Koh, Daniel, Hong, Dennis W.. (2026). PhoneBot: A Low-Cost Open Humanoid Robot Platform Reusing Smartphones. doi.org. dtil
  9. Zakka, Kevin, Tabanpour, Baruch, Liao, Qiayuan, Haiderbhai, Mustafa, et al.. (2025). MuJoCo Playground. doi.org. dtil
  10. Seo, Younggyo, Sferrazza, Carmelo, Chen, Juyue, Shi, Guanya, et al.. (2025). Learning Sim-to-Real Humanoid Locomotion in 15 Minutes. doi.org. dtil
  11. Gu, Zhaoyuan, Li, Junheng, Shen, Wenlan, Yu, Wenhao, et al.. (2025). Humanoid Locomotion and Manipulation: Current Progress and Challenges in Control, Planning, and Learning. doi.org. dtil
  12. Stephens, Benjamin. (2007). Humanoid push recovery. doi.org. dcrtil
  13. Pratt, Jerry; Carff, John; Drakunov, Sergey; Goswami, Ambarish. (2006). Capture Point: A Step toward Humanoid Push Recovery. doi.org. dcrtil
  14. Twan Koolen, Tomas de Boer, John Rebula, Ambarish Goswami, et al.. (2012). Capturability-based analysis and control of legged locomotion, Part 1: Theory and application to three simple gait models. doi.org. dcrtil
  15. Yang, Lizhi, Werner, Blake, Ghansah, Adrian B., Ames, Aaron D.. (2025). Bracing for Impact: Robust Humanoid Push Recovery and Locomotion with Reduced Order Models. doi.org. dtil
  16. Zhang, Tong, Zheng, Boyuan, Nai, Ruiqian, Hu, Yingdong, et al.. (2025). HuB: Learning Extreme Humanoid Balance. doi.org. dtil
  17. Zhou, Yikai, Wang, Xingyun, Cui, Jieming, Chen, Bozhou, et al.. (2026). A Change of Frame Makes the Capture Point Proprioceptive: Distillation-Free Humanoid Single-Leg Balance. doi.org. dtil
  18. Liao, Qiayuan, Zhang, Bike, Huang, Xuanyu, Huang, Xiaoyu, et al.. (2024). Berkeley Humanoid: A Research Platform for Learning-based Control. doi.org. dtil
  19. Wang, Yushi, Chen, Penghui, Han, Xinyu, Wu, Feng, et al.. (2025). Booster Gym: An End-to-End Reinforcement Learning Framework for Humanoid Robot Locomotion. doi.org. dtil
  20. O. Stasse, T. Flayols, R. Budhiraja, K. Giraud-Esclasse, et al.. (2017). TALOS: A new humanoid research platform targeted for industrial applications. doi.org. dcrtil
  21. Cha, Junhyeok Rui, Cha, Woohyun, Shin, Jaeyong, Kim, Donghyeon, et al.. (2025). Sim-to-Real of Humanoid Locomotion Policies via Joint Torque Space Perturbation Injection. doi.org. dtil
  22. Chen, Penghui, Wang, Yushi, Luo, Changsheng, Cai, Wenhan, et al.. (2025). HiFAR: Multi-Stage Curriculum Learning for High-Dynamics Humanoid Fall Recovery. doi.org. dtil
  23. Azulay, Osher, Xu, Zhengjie, Scheffer, Andrew, Yu, Stella X.. (2026). Unified Perceptive Fall Safety for Humanoids. doi.org. dtil
  24. Wong, Lik Hang Kenny, Kang, Xueyang, Bai, Kaixin, Zhang, Jianwei. (2025). A Survey of Robotic Navigation and Manipulation with Physics Simulators in the Era of Embodied AI. doi.org. dtil
← Previous
How Long Can a Humanoid Robot Hold a Box? Joint Torque, Motor Heat and Battery Limits o...
Next →
Next article coming soon
All Future of AI articles (29)29 / 29
Version History · 2 revisions
+
RevDateStatusActionBySize
v1Nov 16, 2026DRAFTInitial draft
First version created
(w) Author0 (~0)
v2Nov 16, 2026CURRENTPublished
Article published to research hub
(w) Author25,189 (+25189)

Versioning is automatic. Each revision reflects editorial updates, reference validation, or formatting changes.

Recent Posts

  • AI Data Readiness Score: Label Noise Hurts 5x More Than Missing Data
  • KV Cache Quantization Benchmark: 4-Bit KIVI Finds 30 of 30 Needles
  • 7 Open Source Humanoid Robots Pushed in Simulation: Feet Beat Torque
  • Llama vs Qwen vs Gemma on a CPU: 3.5 GiB of KV Cache for a 0.6B Model
  • How Long Can a Humanoid Robot Hold a Box? Joint Torque, Motor Heat and Battery Limits on Five Open Robot Models

Research Index

Browse all articles — filter by score, badges, views, series →

Categories

  • ai
  • AI Economics
  • AI Memory
  • AI Observability & Monitoring
  • AI Portfolio Optimisation
  • Ancient IT History
  • Anticipatory Intelligence
  • Article Quality Science
  • Capability-Adoption Gap
  • Cost-Effective Enterprise AI
  • Future of AI
  • Geopolitical Risk Intelligence
  • hackathon
  • healthcare
  • HPF-P Framework
  • innovation
  • Intellectual Data Analysis
  • Living NPCs
  • medai
  • Medical ML Diagnosis
  • Open Humanoid
  • Research
  • ScanLab
  • Shadow Economy Dynamics
  • Spec-Driven AI Development
  • Technology
  • Trusted Open Source
  • Uncategorized
  • Universal Intelligence Benchmark
  • War Prediction
  • Кафедра ЕКІТ

About

Stabilarity Research Hub is dedicated to advancing the frontiers of AI, from Medical ML to Anticipatory Intelligence. Our mission is to build robust and efficient AI systems for a safer future.

Language

  • Medical ML Diagnosis
  • AI Economics
  • Cost-Effective AI
  • Anticipatory Intelligence
  • Data Mining
  • 🔑 API for Researchers

Connect

Facebook Group: Join

Telegram: @Y0man

Email: contact@stabilarity.com

© 2026 Stabilarity Research Hub

© 2026 Stabilarity Hub | Powered by Superbs Personal Blog theme
Stabilarity Research Hub

Open research platform for AI, machine learning, and enterprise technology. All articles are preprints with DOI registration via Zenodo.

410+
Articles
20+
Series
DOI
Archived

Research Series

  • Medical ML Diagnosis
  • Cost-Effective Enterprise AI
  • Future of AI
  • Trusted Open Source
  • Geopolitical Risk Intelligence
  • Capability–Adoption Gap
  • Spec-Driven AI
  • Shadow Economy Dynamics

Community

  • EKIT Department
  • Join Community
  • MedAI Hack
  • Zenodo Collection
  • GitHub
  • contact@stabilarity.com

Legal

  • Terms of Service
  • About Us
  • Contact
  • CC BY 4.0 License
Operated by
Stabilarity OÜ
Registry: 17150040
Estonian Business Register →
© 2026 Stabilarity OÜ. Content licensed under CC BY 4.0
Terms About Contact
Language: 🇬🇧 EN 🇺🇦 UK 🇩🇪 DE 🇵🇱 PL 🇫🇷 FR
Display Settings
Theme
Light
Dark
Auto
Width
Default
Column
Wide
Text 100%

We use cookies to enhance your experience and analyze site traffic. By clicking "Accept All", you consent to our use of cookies. Read our Terms of Service for more information.