Map the Failure Boundary
Traditional software relies on unit tests. Non-deterministic AI, from LLM agents to RL policies, relies on static benchmarks and single-trajectory evaluations. But knowing a system succeeded once doesn’t tell you how reliably it will succeed again.
We built Monte to map the failure boundaries of decision-making systems. As a first test of the instrument, we froze a trained Unitree Go1 locomotion policy and tested it against 6,400 combinations of floor friction and lateral push. The result is a map of where the policy recovers and where it falls.
For each condition, Monte spins up the physics, runs repeated rollouts, and estimates the probability of surviving a five-second episode. The same system lets us probe individual worlds, inspect the resulting trajectories, and re-run the experiment after retraining.
6,400 rollouts · 20×20 conditions · 16 trials per cell · 126 s of GPU time
At a glance
- the failure boundary is broad and variable: a band, not a threshold
- below μ ≈ 0.15, the policy usually falls before the push matters
- retraining on pushes + low friction moved the boundary outward in 60 cells and worsened none
- the full experiment, including retraining and the repeat sweep, cost $42
Monte runs the sweep, the statistical analysis, the live probe, and the surface comparison.
The result
The boundary is diagonal: grippier floors tolerate harder pushes. On medium friction the policy survives pushes up to roughly its own bodyweight (about 125 N for this 12.7 kg robot) and fails beyond that. An earlier back-of-the-envelope estimate had put the boundary near 15 N; the measured value is several times higher, which is why this study reports only measured numbers.
The surprising failure mode. Below μ ≈ 0.15 the map goes dark at the left edge: the robot falls at a 10% bodyweight nudge, or with no push at all. On ice the policy can barely walk. That is a different failure mode from being knocked over (the gait itself collapses), and it lives entirely outside the friction range the policy trained on.
The boundary is also not a sharp threshold. Bootstrapping the 16 trials in each cell (2,000 resamples) gives a 95% interval on each row’s crossing point: about ±4% of bodyweight on high friction, ±33% on ice, a 7× spread. A single curve would hide the width, and the width is a finding.
How we measured it
A demonstration video is a single draw from a stochastic system; it says little about the conditions next door. The grid exists to measure the distribution: which conditions the policy survives, and how often, cheaply enough to re-measure after every training change. Monte turns each grid cell into a small experiment: launch the simulator, run repeated trials, record time-to-failure, and aggregate the outcomes into a survival estimate.
- Policy. Go1 joystick locomotion (MuJoCo Playground’s recipe, Brax PPO), trained once for 217.9M steps (736 seconds on one A100) to a nominal reward of 30.30 ± 0.54, then frozen.
- Training distribution. Friction randomized over U(0.4, 1.0), with mass, center-of-mass, and joint jitter, and no pushes. Every push in this study is out-of-distribution by construction, and the bottom third of the friction axis is below anything the policy saw.
- Perturbation. A constant lateral force on the torso for 0.5s, starting at t=2s, applied in physics only; the observation the policy sees is untouched. 100% of bodyweight = 125.0 N.
- Failure. Torso below 0.15 m or tilt past 60°, whichever comes first, with thresholds frozen before the sweep. Rollouts that survive the 5-second window are censored, not counted as late failures. We use survival analysis (Kaplan–Meier per cell) precisely because some trials never fail.
How much should we trust the map?
We tested the measurement itself, three ways.
Harness fidelity. The evaluation harness reproduces the training environment: we verified that replaying the nominal trajectory through the injection path yields identical states over 500 steps, and that the push enters through physics only.
Numerical sensitivity. Halving the timestep moved the boundary within bootstrap noise; doubling solver iterations moved it by about 17% of bodyweight. Real and reported, but small relative to the structure. The diagonal band and the ice cliff persist under every solver setting we tried.
Nondeterminism. Repeated GPU runs of the same program and seed can diverge: floating-point reduction order is not fixed, and a thousand steps of contact dynamics amplify it. This is why we report distributions rather than individual trajectories. It also has a sharp consequence: some knife-edge survivors cannot be re-simulated. Their replay exists in the cache or not at all, which is why the first probe of each world is kept as its canonical record.
Training for the failures
Having checked the measurement, we used it. The map identified two conditions missing from training: the policy had never been pushed, and had never walked on friction below 0.4. We changed exactly those two settings (the environment’s own perturbation kicks, and a friction range widened to U(0.1, 1.0)), retrained with an otherwise identical recipe in about 12 minutes, and ran the same sweep again.
60 of the 400 cells became significantly safer (Fisher’s exact test with Benjamini–Hochberg correction across all cells, q < 0.05). None became significantly worse. The measured crossing (each row’s bootstrap-median boundary) moved outward on every friction row, most in the regions where training was widened: at μ=0.10 it rose by about 66% of bodyweight, and at μ=0.05, where the baseline could not walk at all, the retrained policy gained a boundary at all, with its survival crossing near a 50% bodyweight push. High-friction rows, already inside the original training distribution, moved only 4–8%.
The useful part of the map is what it lets us do next: change the policy, run the same test, and compare the two surfaces cell by cell.
Probe the map
The map is also interactive: pick a friction/push combination with the sliders and the corresponding rollout loads in the viewer. Worlds that have been probed before are cached and load instantly, at no cost; a new world runs a fresh rollout on a serverless A100 via Modal (about 3 seconds warm, ~25 seconds cold) and its first replay becomes the canonical record for that world.
What it cost
All of the compute runs on Modal’s serverless A100s, scaled to zero between uses. A full 6,400-rollout sweep takes about 126 seconds; a fresh interactive probe is about 0.5 seconds of physics and 3 seconds end-to-end when warm.
- Training: 736 seconds, once. Retrain + re-sweep + diff: about 14 minutes.
- Idle, between probes: $0.
- The full experiment, including retraining and the repeat sweep: $42, read off the bill rather than a rate card.
At that cost, the evaluation is cheap enough to run routinely, after every training change, rather than only as a final audit.
What this does and doesn’t show
This is a map of one policy’s failures inside the simulator it was trained in. It is not a claim about a physical Go1 on a physical floor: the boundary is per-policy and per-simulator, and the ice regime in particular is far outside the training distribution. Reproducibility across hardware is statistical (the surface within tolerance), not bitwise, for the nondeterminism reasons above.
Closing
We started with a frozen policy, mapped where it failed, changed the two parts of training the map identified, and ran the same test again. The second surface improved where we expected it to improve.
The useful idea is the loop: sweep, inspect failures, retrain, and re-run the sweep, at a cost that makes it practical to repeat.
The tooling behind this study is Monte: the sweep, the live probe, and the surface diff. The same evaluation pattern could apply to other learned systems whose behavior is too stochastic for single demonstrations to say much.
Built on MuJoCo Playground, MuJoCo Menagerie (Unitree Go1 model), Brax, Rerun, and Modal. The Go1 model and Playground recipe are used under their respective licenses.