We built a small robot to test a large idea. The robot is a soft wheel: a hub, a ring of rim points around it, and a set of spoke "muscles" that pull between them. It lives inside a differentiable physics simulator called AlgoVivo. Its whole job is to roll across the floor and reach a finish line. What we wanted to know was not whether it could move — a fixed wave of muscle contractions can do that — but whether it could keep moving when the world started out wrong.
So we gave it two drivers to compare. The first is a plain open-loop math gait: a fixed sinusoidal wave sent through the muscles, no feedback, no choices — the honest baseline. The second is a persistent UDI controller that watches the body and, on every step, outputs one of three things: commit a muscle pattern, refuse it, or NULL — do nothing yet. We ran the whole thing headless in pure Node, so every number below re-runs to the same value.
The test that mattered: where you start.
A controller that only works from one starting pose is a demo, not a robot. The real world does not set you down at zero degrees. So we rotated the wheel's initial orientation across 16 angles, evenly spaced from 0 to 330 degrees, and asked the same simple question at each one: did it reach the finish?
The baseline math gait reached the finish from 11 of 16 start angles. The frozen UDI controller did better — 15 of 16 — which was encouraging until we looked at the one it missed. At 90 degrees it did not merely stall. It locked into rolling backward and never recovered, ending roughly 58 meters the wrong way. A confident, sustained, wholehearted run in exactly the wrong direction.
The failure was not weakness. It was conviction pointed the wrong way.
The diagnosis.
We traced it. Once the wheel had picked up backward momentum, the controller kept committing muscle patterns that rode the wrong-way roll — each commit locally reasonable, all of them together a runaway. We tried flipping the controller's internal hand, its sense of which way to push, and it did not help: flipping a preference does not arrest a body that already has momentum. The deeper cause sat further back. A single spurious early confirm had corrupted the controller's learned sense of direction into a backward lock, and everything after it faithfully served that corrupted belief.
The fix: let it refuse.
We did not add force. We added permission to stop — in the spirit of the whole project. When measured progress backslides by more than one wheel radius — the body's own scale, not a number we tuned to pass the test — the controller NULL-brakes: it relaxes every muscle, lets the momentum bleed off, re-centers, and re-seeds its direction from the measured polarity of the body rather than from the corrupted learning. It is the eye of the storm, made mechanical: a deliberate moment of doing nothing so the next commitment can be a good one.
| Driver | Reached finish |
|---|---|
| Math gait (open-loop) | 11 / 16 |
| UDI controller (frozen) | 15 / 16 |
| UDI controller (amplified) | 16 / 16 |
The amplified UDI controller reached the finish from all 16 of 16 start angles — with zero regressions. On the 15 cases that already worked, the runs are byte-identical to before: the brake never fires when it is not needed. At 90 degrees, two brakes fire, the backward run is arrested, and the wheel then rolls forward through the finish. The gate did nothing at all until refusing was the right move, and then it refused hard.
Where we caught ourselves.
Honesty note, kept in plain sight because it nearly fooled us. While building the test harness, an earlier version set the simulation's stiffness after the settle step. Under that ordering the 90-degree failure quietly disappeared — and with it, the entire justification for the fix. For an afternoon it looked like we had solved a problem that did not exist. The failure is sensitive to initial conditions; small differences in how the body is set up decide whether it appears. We fixed the harness to match the real host — stiffness applied before settle — and we are leaving this paragraph in the write-up so the sensitivity is not hidden. The full run is frozen at experiments.ado.earth with sha-256 hashes and a one-command runner, so you can reproduce both the failure and the fix rather than take our word.
What this is not.
This is in-simulation: one wheel, one course, one simulator. It is not a physical robot, and it is not a claim of general locomotion or intelligence. The result we are reporting is narrow — a specific failure mode found, diagnosed, and closed without breaking anything else. Wider forks are next: different spoke counts, different friction, uneven terrain. We expect some of those to break it again, and when they do we will keep the failures.
The lesson does generalize, though, past this one small machine. Sometimes the most capable move a system can make is not to push harder. It is to stop, refuse the bad commitment it is in the middle of, and re-center on what it can actually measure. This wheel did not get robust by getting stronger. It got robust by being allowed to quit a run that was going nowhere good.