← all tasks

hopper-blackout-noisy

Hopper (MuJoCo Hopper-v5) · solvedexploration 3 of 9 agent attempts pass

Exploration task. Built after the paper's sweep to test whether a task can force a mechanism outside the catalogue (docs/exploration_new_mechanisms.md, docs/soft_arm_spec.md). Not part of the benchmark tiers or of the paper's main counts; the soft arm is reported in the paper as a plant outside the sweep, the other tasks are not; all sessions ran under the paper's protocol.

The task. Exploratory task (not one of the benchmark tiers reported in the paper; see docs/exploration_new_mechanisms.md): intermittent sensing under noise, the follow-up to hopper-blackout.

more

With probability 0.015 per 8 ms control step the sensors hold their values for 12 steps (96 ms), roughly 15 % of the time, while the plant moves on, and every reading carries fresh Gaussian noise of 0.01, so a blackout is not a repeated observation. In hopper-blackout all nine sessions detected the freeze from the bit-identical reading and the passes bridged it with a copy of the plant; here the staleness has to be inferred from the disagreement between a reading and the motion the plant can have made, i.e. a model-based estimator with a consistency test has to run on every step, or the gait has to tolerate 96 ms of stale, noisy state. Physics nominal; gate forward (3 m) on 0.9 of the seeds. Open: the hopper-forward oracle scores 0 under blackouts.

Gate. per-seed success is the `forward` rung of this benchmark's ladder ['alive', 'forward', 'brisk', 'fast'] (`--success-mode forward`), 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:hopper, scenario:blackout_noisy_v1, gate:forward_3m, exploration:new-mechanism, sensing:intermittent, sensing:noisy

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 attemptSonnet 5.5 (claude-code (exploration), 46 min) · blackout_noisy_v1

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

criteriongradedneeded
base:forward1.000≥ 0.900

How the agent got there: 46 min · 67 tool calls · 1 edit-tool edits · 37 runs of its own Python (tests, experiments, rewrites) · no tuner runs · official verifier 5× (success rates in order: 0.85, 0.88, 0.98, 1.00, 1.00).

The agent's final message

`/app/work/controller.py` passes the gate on the blackout scenario: 98% `forward` success (59 of 60 seeds, 20–79) and 100% on seeds 0–19 and 0–4. The one failure was seed 54, which crashed at 8.4 m when the torso dropped below 0.7 m. The runs used the sandbox evaluator, `blackout_noisy_v1` and `--success-mode forward`, and about 46 of the 60 minutes were used. - **Policy:** it is a linear feedback law on the 11 Hopper-v5 observables plus a foot-contact flag. I found its gains with gradient-free random search, with no neural network. The first version stood still or crept. It only learned to hop once I dropped the +1 alive bonus from the search reward. - **Speed cap:** the final fine-tune capped the rewarded forward speed at 1.6 m/s, which cut falls. The gait still covers about 17.5 m per episode, which is `brisk` but not `fast`. - **Blackouts:** the controller runs a MuJoCo copy of the plant inside it, which assumes the grader's environment has `mujoco` and `hl_control` installed (as the sandbox does). It steps that copy with the last applied command, then checks each reading against the previous raw reading. A reading that repeats the previous one to within the noise, and fits that better than the prediction, is treated as stale and replaced by the prediction. Live readings are blended in, or adopted outright after a big disagreement such as an impact. - **Why the estimator matters:** the first, simpler estimator accepted too many stale readings, and the policy passed only …

Controller family: linear policy tuned by search

A 3x12 linear policy found by ARS acts on normalized features from a simulator-based estimator that predicts state with a MuJoCo copy, discards stale blackout readings, blends live readings with gain K, and snaps to measurements on large innovations.

Shown: public seed 0 (blackout_noisy_v1); this episode passes the forward rung. This episode: episode_steps 1000, x_final 17.5, min_height 0.973, max_abs_pitch 0.0522, n_flights 13, total_reward 3192.

controller.py · agent transcript · trial hopper-blackout-noisy__UremSRQ

FailureFable 5.1 (claude-code (exploration), 48 min) · blackout_noisy_v1

Graded on the held-out seeds: misses the main gate narrowly (success rate between 0.5 and the gate).

criteriongradedneeded
base:forward0.825≥ 0.900

How the agent got there: 48 min · 53 tool calls · 0 edit-tool edits · 46 runs of its own Python (tests, experiments, rewrites) · no tuner runs · official verifier 5× (success rates in order: 0.30, ?, ?, ?, ?).

The agent's final message

Final state: `/app/work/controller.py` holds the best controller found. It does not reach the 0.9 gate on the blackout plant, so the result should be read as a partial solution. **Outcome on the task plant (`blackout_noisy_v1`), forward rung** | Seeds | Evaluator | Forward rate | |---|---|---| | 0-29 | official `verify` | 0.77 (alive 0.83) | | 0-69 | my rollout script | 57/70 = 0.81 | | 50-69 (never used for tuning) | my rollout script | 16/20 = 0.80 | | 0-9 on `standard_v0` | official `verify` | 1.00 (alive 1.00) | Failures split into two kinds: a pitch excursion past 0.2 rad on a landing (the robot falls), and episodes where the bounce dies out and the robot stands still short of 3 m. **What the controller does** - **Stance:** the hip is a pitch servo whose target leans back as speed exceeds the desired value. The knee is a stiff PD strut. The ankle acts as a leg spring that plantarflexes in proportion to how far the thigh trails behind the torso, so the toe push launches the forward-leaning body up and forward. An extra hip gain engages when pitch passes 0.15 rad. - **Flight:** PD to a landing posture, with the ankle set to land the foot flat and a weak hip pitch servo that uses the heavy leg as a reaction wheel. Knee and ankle commands ramp in over the first 0.4 s. - **Blackouts:** stale readings are detected when the joint angles stop moving as the measured rates say. For the following 9 steps the law runs on dead-reckoned angles and pitch, with height propagated ba…

Controller family: other: phase-based hand-tuned gait controller (stance/flight PD with toe push-off)

A contact-driven hopper controller uses PD servos for pitch, knee and ankle in stance with a toe push proportional to thigh lag, switches to flight-phase PD foot placement, and during detected sensor blackouts runs the same law on dead-reckoned states.

Shown: public seed 3 (blackout_noisy_v1); this episode fails the forward rung. This episode: episode_steps 841, x_final 1.69, min_height 1.14, max_abs_pitch 0.205, n_flights 6, total_reward 1052. It was the first failing one of 4 public seeds tried.

controller.py · agent transcript · trial hopper-blackout-noisy__v4ETQy5

FailureFable 5.1 (claude-code (exploration), 50 min) · blackout_noisy_v1

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

criteriongradedneeded
base:forward0.200≥ 0.900

How the agent got there: 50 min · 69 tool calls · 0 edit-tool edits · 52 runs of its own Python (tests, experiments, rewrites) · no tuner runs · official verifier 3× (success rates in order: 0.80, 0.75, 0.80).

The agent's final message

The budget is nearly spent (50 of 60 minutes used), so I'm stopping here with the best controller saved at `/app/work/controller.py`. **Outcome: below the gate.** On the visible seeds under `blackout_noisy_v1` the submitted controller passes the forward rung on 4 of 5 seeds (0.8 success rate, gate 0.9), and on 9 of 12 seeds when I widened the range. The failure mode is always the same: a fall from pitching out of band, not a sensing error. | Visible-seed metric | Value | |---|---| | forward success (seeds 0-4) | 0.80 | | forward success (seeds 0-11) | 0.75 | | mean distance when alive | about 9 m | | mean return | about 1875 | **What the controller does.** It is a phase machine driven mostly by the clock: lean the standing robot forward with the ankle, then knee thrust plus toe push, a knee tuck to lift the foot, a flight phase with a hip PD mixing torso pitch and landing thigh angle, and a knee re-extension before touchdown. Thrust and toe push shrink when the robot is faster than the target speed. A stale-sensor filter detects blackouts from the collapse of the per-step change in the six measured rates, dead-reckons the state from the last live sample, predicts touchdown ballistically, and mutes the hip torque in stance while readings are stale. Gains came from a (1+λ) evolution search on the blackout plant. **What limits it.** The leg is far heavier than the torso, so the hip cannot place the foot ahead of the body in flight. Each landing therefore happens with the foo…

Controller family: lookup table / heuristic rules

A clock- and event-driven hopping state machine uses PD servos and a thrust, tuck and flight sequence with speed-dependent corrections, while a filter dead-reckons through sensor blackouts and gates the hip torque; gains were tuned with a (1+lambda) evolution search.

Shown: public seed 0 (blackout_noisy_v1); this episode fails the forward rung. This episode: episode_steps 399, x_final 3.38, min_height 1.15, max_abs_pitch 0.205, n_flights 5, total_reward 821. It was the first failing one of 1 public seeds tried.

controller.py · agent transcript · trial hopper-blackout-noisy__LqDFYNo