← all tasks

humanoid-brisk

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

The task. The brisk rung (8 m of mass-centre progress in 15 s, 0.53 m/s, alive) on 90 % of held-out seeds, from the zero-torque starter.

more

Flat counterpart of humanoid-brisk-handoff. The oracle is the humanoid-forward design with its gait parameters re-tuned by the repository tuner for this rung (14.7 m, return 5918, the SAC return regime), which shows the rung is reachable with the classical structure; whether an agent reaches it from scratch in one session is what the task measures.

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

Axes: plant:humanoid, scenario:standard_v0, gate:brisk_8m, rl-reference:sac-v5-local

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 attemptOpus 5.5 (claude-code, 35 min) · standard_v0

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

criteriongradedneeded
base:brisk1.000≥ 0.900

How the agent got there: 35 min · 82 tool calls · 6 edit-tool edits · 51 runs of its own Python (tests, experiments, rewrites) · no tuner runs · official verifier 3× (success rates in order: 0.80, 1.00, 1.00).

The agent's final message

`/app/work/controller.py` now passes the grading gate. The official verifier solves seeds 0–4 at 5/5 `brisk`. My own harness, which runs the same environment class, gives 197/197 `brisk` over seeds 0–191; 176 of those seeds were never used for tuning. The robot walks about 11.3 m in 15 s on average (about 0.75 m/s), and the lowest root height I saw was around 1.22 m, well above the 1.0 m fall line. **How the controller works** (the docstring in the file explains each gain): - **Gait timing:** one leg holds the body while the other swings, for about 0.2 s per step. The legs swap when the swinging foot touches down. - **Trunk balance:** the standing leg's hip keeps the trunk upright, as in the well-known SIMBICON walking controller. The robot leans its trunk slightly over the standing leg, because the sideways hip motors (40 N·m at most) can't otherwise hold the trunk up. - **Turning drift:** the feet are spheres with no twisting friction, so the hip yaw motor can't stop the body from turning. Without a fix, the robot drifted 1–2 rad in a few seconds. The fix adds a small forward/backward torque at the standing hip, with its sign set by which foot is down. Because that foot sits off to one side, this produces a turning torque. - **Foot placement:** each swing foot is aimed at a point set from the body's speed (Raibert-style stepping). Leg angles come from full 3D leg geometry, which I checked against MuJoCo to within about 1 cm. - **Tuning:** I chose the structure by hand; han…

Controller family: Raibert / foot placement

A two-state stepping controller alternates stance and swing legs. The swing foot is placed Raibert-style relative to the CoM using velocity-error feedback and tracked through analytic 3D IK with joint PD. The stance hip holds trunk pitch, roll and yaw by SIMBICON-style torques, and the stance knee is held stiff.

Shown: public seed 0 (standard_v0); this episode passes the brisk rung. This episode: episode_steps 1000, x_final 11.6, min_height 1.24, max_abs_pitch 0.475, n_steps 66, total_reward 5794.

controller.py · agent transcript · trial humanoid-brisk__akrYoKa

FailureFable 5.1 (claude-code, 52 min) · standard_v0

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

criteriongradedneeded
base:brisk0.400≥ 0.900

How the agent got there: 52 min · 56 tool calls · 0 edit-tool edits · 29 runs of its own Python (tests, experiments, rewrites) · repository tuner 18× · official verifier 2× (success rates in order: 0.60, 0.80).

The agent's final message

Final state at 11:43 UTC, about 51 minutes into the 60-minute budget. The controller at `/app/work/controller.py` walks forward at roughly 0.55 m/s but does not yet reach the 0.9 gate: it clears the brisk rung on 4 of the 5 visible seeds in the official evaluator and on about 45 to 50 % of fresh seeds in my own rollouts. **What the controller is** A hand-designed SIMBICON-style stepping controller, no learning. Two-state gait machine (right or left stance) swapping on swing-foot touchdown. Every joint runs a PD law with a small derivative gain. The swing foot is placed by a Raibert capture law using the mass-centre velocity and its offset from the stance foot, expressed in the torso's yaw frame with the goal direction set to world x. The stance knee is pressed onto its hard stop so the stance leg acts as a rigid strut, and the stance hip plus abdomen run a torso-attitude servo. Twelve gains sit in a `PARAMS` dict and were searched with the bundled tuner. **Results** | Evaluation | alive | brisk | |---|---|---| | Official evaluator, seeds 0-4 | 5/5 | 4/5 | | My rollouts, 36 fresh seeds (24-59) | 24/36 | 17/36 | **What I found along the way** - The dominant early bug was derivative gain: anything above about 0.02 command units per rad/s makes every PD loop bang between its limits at the 15 ms sample time. - The model starts 10 cm above the floor, so a settle phase is needed before stepping. - The stance foot is a frictionless-in-torsion sphere, so yaw cannot be controlled…

Controller family: SIMBICON

A SIMBICON-style stepping controller alternates right/left stance using touchdown or timeout, places the swing foot from COM velocity and offset, bends the swing knee for clearance, and servos torso pitch and roll through the stance hip while PD-holding the other joints.

Shown: public seed 1 (standard_v0); this episode fails the brisk rung. This episode: episode_steps 1000, x_final 7.95, min_height 1.25, max_abs_pitch 0.246, n_steps 144, total_reward 5489. It was the first failing one of 2 public seeds tried.

controller.py · agent transcript · trial humanoid-brisk__SsadwzE

FailureOpus 5.5 (claude-code, 52 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: 52 min · 52 tool calls · 1 edit-tool edits · 28 runs of its own Python (tests, experiments, rewrites) · no tuner runs · official verifier 2× (success rates in order: ?, 1.00).

The agent's final message

The controller in `/app/work/controller.py` passes the `brisk` gate: the official evaluator scores 5/5 on seeds 0–4 (mean 10.1 m, return 5445). **How it works:** it's a sampling-based model-predictive controller, so there's no learning involved. - **State:** each step it reads the full simulator state from `obs["gym_obs"]`. - **Plan:** it keeps a short plan of joint-angle targets (4 knots over 0.6 s), applied through a PD law, `u = clip(kp·(q* − q) − kd·q̇, ±0.4)`. - **Sampling:** each step it tries 96 random variations of the plan on a copy of the robot model, using MuJoCo's batch rollouts. It applies the first target of the cheapest one. - **Cost:** stay above 1.3 m with a heavy penalty below 1.08 m, keep the torso upright and facing +x, keep the predicted point of balance between the feet, and track a forward speed that ramps up to 1.2 m/s. - **Slow-down:** once 9.5 m is covered, the speed target drops to 0.6 m/s, so the gate distance is already reached and the late-episode stumble risk is lower. The docstring explains the control law and every entry in `PARAMS`. **Results with this exact file:** - **Seeds 0–4 (official evaluator):** 5/5 pass. - **Seeds 16 and 24–34 (my own runner):** 12/12 completed all 1000 steps, 9.3–10.8 m. - **Seeds 35–46:** all 12 were standing at step 900 and had already covered 9.3–10.2 m. That batch hit its 10-minute background limit before step 1000, so it isn't a confirmed pass. **Before the slow-down:** the version without it went 21/22 on …

Controller family: MPC (sampling/shooting)

Each step it samples 96 Gaussian perturbations of a 4-knot joint-target plan, rolls them out in parallel in MuJoCo with PD servos, scores them with upright/height/capture-point/velocity costs, and applies the first PD command of the cheapest plan.

Shown: public seed 23 (standard_v0); this episode fails the brisk rung. This episode: episode_steps 943, x_final 8.6, min_height 0.977, max_abs_pitch 0.439, n_steps 174, total_reward 5034. It was the first failing one of 24 public seeds tried.

controller.py · agent transcript · trial humanoid-brisk__rbEemmr