← all tasks

humanoid-parity

Humanoid (MuJoCo Humanoid-v5) · solved 3 of 9 agent attempts pass

The task. The fast rung (15 m in 15 s, alive, on 90 % of seeds) plus a mean return within 10 % of a committed RL reference measured on the grader's own seeds: SB3 SAC trained here on Gymnasium Humanoid-v5 for 2 M steps with the RL-zoo hyperparameters (rl_references/humanoid/train_sb3_sac.py; the plant reproduces Gymnasium step for step, verified seed by seed); the reference is the 1.8 M-step checkpoint, the best of the last four on 20 non-task seeds (the 2 M final falls on 1 of 20): return 5579 +- 666 (min 1425), alive 0.97, 11.8 m, 0.80 m/s, fast 0.00; inside Gymnasium 5667 +- 28 -> bound 5020.

more

The SAC policy itself walks at about 0.8 m/s and does not clear the fast rung. The oracle is the classical fast_v1 design (return 6083), so the rung is reachable without learning; the agents' question is whether a session finds it. Provenance under tests/reference/.

Gate. per-seed success is the `fast` rung of this benchmark's ladder ['alive', 'forward', 'brisk', 'fast'] (`--success-mode fast`), not the evaluator's default flag; the task is solved when the success rate over the grader's held-out seeds is `>= 0.9`; the aggregate `total_reward_mean` over the grader's held-out seeds (base scenario) must be `>= 5020` (rung `metric:total_reward_mean`)

Axes: plant:humanoid, scenario:standard_v0, gate:fast_15m, rl-parity:sac-v5-1.8M-minus-10pct

Each video re-runs the attempt's final controller through the task's own evaluator on a public seed (never the grader's held-out ones). The table under each video is the official grade on the held-out seeds.

Best attemptFable 5.1 (claude-code, 44 min) · standard_v0

Graded on the held-out seeds: passes every gate on the grader's held-out seeds.

criteriongradedneeded
base:fast1.000≥ 0.900
metric:total_reward_mean6315≥ 5020

How the agent got there: 44 min · 60 tool calls · 1 edit-tool edits · 37 runs of its own Python (tests, experiments, rewrites) · no tuner runs · official verifier 4× (success rates in order: 1.00, 1.00, 1.00, 0.95).

The agent's final message

The final controller is in place at `/app/work/controller.py` and passes the gate with margin. I'm stopping here with about 15 minutes of budget left, since the submission is already passing and the remaining candidates I screened were less robust. **Result** | Check | Value | |---|---| | Fast rung, 20 visible seeds (official evaluator) | 19/20 | | Fast rung, 196 fresh seeds (own harness) | 193/196 (98.5%) | | Return mean, base scenario | about 6300 (gate 5020) | | Mean speed | 1.16 m/s, about 17.5 m per episode | **Controller design** - A SIMBICON-style two-state walker. The stance leg alternates when the swing foot touches down, with time bounds on the step. - The swing foot is placed in world coordinates from the mass-centre position and velocity relative to the stance foot, both sagittally and laterally. This foot placement is what balances the robot, since the spherical feet give no ankle torque. - The stance hip regulates torso pitch, with partial compensation of the swing-hip reaction torque. Roll is handled the same way on the hip-roll motors. - All 26 gains were found with a hand-written CMA-ES in `scratch/cma.py` on random seeds, then every fully surviving candidate was re-screened on 40 to 100 fresh seeds before installation. No neural networks or gradients were used. **Dead ends and caveats** - An open-loop sinusoidal gait with pitch feedback could not stand for more than a second. Early SIMBICON gains saturated the 0.4 command range and the stance roll torq…

Controller family: SIMBICON

A SIMBICON-style walker alternates left/right stance states on swing-foot contact or timeout, places the swing thigh with linear COM distance/velocity feedback, controls torso pitch and roll through the stance hip, and runs PD servos on the other joints with clipped outputs.

Shown: public seed 0 (standard_v0); this episode passes the fast rung. This episode: episode_steps 1000, x_final 17.7, min_height 1.21, max_abs_pitch 0.73, n_steps 85, total_reward 6325.

controller.py · agent transcript · trial humanoid-parity__gT2WEYE

FailureSonnet 5.5 (claude-code, 53 min) · standard_v0

Graded on the held-out seeds: fails the main gate badly (success rate below 0.5).

criteriongradedneeded
base:fast0.000≥ 0.900
metric:total_reward_mean5101≥ 5020

How the agent got there: 53 min · 55 tool calls · 0 edit-tool edits · 22 runs of its own Python (tests, experiments, rewrites) · no tuner runs · official verifier 2× (success rates in order: 0.40, 0.00).

The agent's final message

The controller does not solve the task. The `fast` rung needs ≥15 m, and the best I got is about 3.7 m per episode, so the success rate on seeds 0–4 is 0/5. I stopped at about 53 of the 60 minutes. `/app/work/controller.py` holds the best version I had. On the visible seeds 0–4 on the nominal plant: - **Ladder:** alive 5/5 and forward (≥3 m) 5/5. Brisk (≥8 m) and fast (≥15 m) are 0/5. - **Reward:** the mean is 5109, which clears the 5020 reward gate. That gate is separate from the success rate, and the success rate is what fails. - **Held-out check:** on 12 other seeds, mean reward was 5102, alive in all 12, with distances of 3.5–3.8 m. The controller is a clock-driven gait, with Fourier-series targets for the legs and each leg half a cycle behind the other. It adds PD joint torques and feedback from pitch, roll, yaw and forward and lateral speed. The numbers are in `THETA` and were found with a CMA-ES search I wrote (`opt.py`, `run1.py`). The search objective was reward plus a bonus for distance. The docstring in `controller.py` explains the control law and what each gain does. The gait is mostly a low-speed shuffle with both feet often off the floor, about 0.25 m/s, not a real stride. Search runs that used a stronger forward bonus or a wider search from this solution reached 5–6 m, but they were still improving slowly and had not reached 15 m when I stopped. I did not run any of the perturbation scenarios (low friction, weak motors, pushes and so on). One earlier solut…

Controller family: CPG / clocked oscillator

A fixed-frequency phase clock generates Fourier-series leg and arm joint targets (left leg half a cycle behind), with pitch, roll, yaw and speed feedback added to the targets and PD torques divided by motor gear and clipped, with all 46 parameters tuned by CMA-ES.

Shown: public seed 0 (standard_v0); this episode fails the fast rung. This episode: episode_steps 1000, x_final 3.85, min_height 1.25, max_abs_pitch 0.241, n_steps 229, total_reward 5115. It was the first failing one of 1 public seeds tried.

controller.py · agent transcript · trial humanoid-parity__4rLEg6j

FailureOpus 5.5 (claude-code, 29 min) · standard_v0

Graded on the held-out seeds: the verifier timed out: the controller was too slow for the 900 s grading budget.

How the agent got there: 29 min · 17 tool calls · 1 edit-tool edits · 11 runs of its own Python (tests, experiments, rewrites) · no tuner runs · official verifier 1× (success rates in order: 1.00).

The agent's final message

I'm leaving the controller in `/app/work/controller.py`. It passes the grading gate on every seed I ran: 11 out of 11 reached the `fast` rung (stayed up for all 1000 steps and covered at least 15 m). **Results on the standard scenario** - **Official verifier, seeds 0–4:** 5/5 `fast`, mean return 6116 (the gate is 5020), mean distance 17.3 m, mean speed 1.15 m/s. - **My own rollout script, seeds 5–10:** all six survived the full episode, covering 16.2–18.1 m with returns between 5993 and 6171. The closest seed walked 16.2 m, so the margin over the 15 m bar is about 1 m. I only tested the standard scenario, not the perturbation scenarios. **How it works** It doesn't use a hand-designed gait. It uses a sampling-based model-predictive controller: - **Internal model:** the controller loads the same humanoid model file into its own MuJoCo copy. Each step it rebuilds the full simulator state from `gym_obs`, which contains every coordinate except horizontal position, and that doesn't matter on a flat floor. - **Plan:** it keeps a smooth command plan 0.6 s long (40 control steps, with a knot every 60 ms). Each step it tries 128 noisy variants of the plan, plus the current plan itself. It runs all of them forward in parallel in a cheaper planning model (7.5 ms timestep, simpler integrator), keeps the lowest-cost one and applies its first command. - **Cost terms:** forward speed of the mass centre towards 1.7 m/s, lateral drift, head height, staying upright, keeping the mass centre's…

Controller family: MPC (sampling/shooting)

Each step it rebuilds the simulator state from the observation, samples 128 noisy spline control plans around a shifted nominal plan, rolls them out in parallel in a copy of the MuJoCo humanoid, picks the lowest-cost plan, and applies its first command.

Shown: public seed 10 (standard_v0); this episode fails the fast rung. This episode: episode_steps 840, x_final 14, min_height 0.971, max_abs_pitch 0.68, n_steps 83, total_reward 5053. It was the first failing one of 11 public seeds tried.

controller.py · agent transcript · trial humanoid-parity__7G6aF8N