Failure monitors that keep learning after deployment

October 15, 2026. Amit Jadhav, Shaurya Beriwala

A robot that runs a vision-language-action (VLA) policy needs a failure monitor: something that watches the policy and raises an alarm before a failing episode ends. Today's monitors are trained once and then frozen. We built one that keeps learning after deployment, from the one label every episode gives for free: whether it succeeded.

Conditions drift, and nobody tells the monitor

A monitor checked in simulation or in the lab has to keep working in the field, and the field does not stand still. Light changes, objects get swapped, someone bumps the camera, gripper pads wear down. Each change can break a frozen monitor in two ways. Its ranking can break, so failing episodes no longer score higher than successful ones. Its calibration can break, so its threshold no longer gives the false-alarm rate the operator asked for.

Nominal: as trained — One LIBERO-Goal scene (task "put the bowl on the stove") as the policy's camera sees it at the start of an episode, under each condition we used on this suite. Worn fingers change how the gripper holds objects but not how the scene looks. Blue walls change the picture but not the success rate.

Dim light: light ×0.25 — One LIBERO-Goal scene (task "put the bowl on the stove") as the policy's camera sees it at the start of an episode, under each condition we used on this suite. Worn fingers change how the gripper holds objects but not how the scene looks. Blue walls change the picture but not the success rate.

The robot does learn how every episode ended. SFF turns that signal into a monitor that adapts to the shifts it meets, fixing both ranking and calibration while the robot keeps working.

Streaming Failure Forecasting

SFF starts from an ordinary offline monitor: a small network trained on 140 normal "warm-up" episodes to predict, at every policy call, whether the episode will fail. Its input is built from the policy's own internal activations. After deployment SFF changes two things and nothing else.

An online head. The network's hidden layers stay fixed and act as a feature map. After every episode, SFF refits only the last, linear layer by discounted least squares, pulled toward the offline head while it has seen few outcomes. The refit is one 130 × 130 linear solve. No episode is stored, so memory stays constant however long the robot runs. Because it starts from the offline head, SFF begins by ranking episodes exactly as the offline monitor does, and improves from there.

A success-only threshold. An alarm can only be false in an episode that succeeded, so the threshold moves only after successes: up if that success raised an alarm, down a little if not. This is adaptive conformal inference applied to successes, and it bounds the long-run false-alarm rate on successes for any score, even one that is still learning.

SFF is never told when conditions change, and every score is logged before any update uses it, so what it reports is exactly what it would have seen live.

One episode, step by step

Call 0 (0 s): SFF 0.03 / threshold 0.53, frozen 0.00 / threshold 0.73

0.0 s / 14.5 s

Task: put the bowl on the stove. Outcome: fails at the time limit.

The scores are logged from the run. The camera frames come from re-simulating that episode; in the failing one the replay follows the log only for the first four policy calls, so later frames are marked "replay only".

In this LIBERO-Goal stream the gripper fingers have worn, which the camera cannot see. SFF has been learning from the episodes before this one and raises the alarm 3.5 s in. The same monitor kept frozen never alarms, and the episode fails at its time limit. In the next episode, same task and same condition, the policy succeeds and SFF stays quiet: it caught the failure without crying wolf.

Results

We recorded SmolVLA rollouts in LIBERO and LIBERO-Plus and turned them into streams: 200 normal warm-up episodes, then 60-episode segments under one condition each. We measure ranking as within-task AUROC: the chance that a failing episode gets a higher peak score than a successful episode of the same task (0.5 is chance). We count episodes 21 to 60 after each change, so we measure how a monitor performs once a condition has settled in.

We designed SFF's head on one suite (Spatial). Then every setting was locked and SFF ran once on five test suites. LIBERO-10 was the primary test, with its pass criterion registered in a time-stamped commit before we ran it.

SFF ahead at one-sided Holm p < 0.05 (the registered test) no clear difference, or the discovery suite (not a test)

SFF ranked failures better than the frozen monitor on 4 of 5 test suites, including the pre-registered primary test (LIBERO-10: 0.707 to 0.736). On LIBERO-Goal, LIBERO-Plus and Spatial with new seeds, SFF was ahead on every single stream.

It beats detect-and-reset everywhere. The usual answer to drift is to detect the change and retrain the monitor from scratch. SFF ranked above that approach on all six suites, by 0.024 to 0.096 AUROC. Even when we handed the reset baseline the true change points, which no real system has, it still ranked below the frozen monitor (0.691 against 0.705): a fresh monitor has too few episodes to learn from. A monitor that remembers what it has learned and keeps adding to it wins.

Refitting one layer is enough. We also tried training the whole network online with streaming TD(λ). Its hidden weights moved only 0.2 to 2.8% over a development stream. Refitting the readout is where the gain comes from, which keeps SFF small and cheap.

False alarms stay on target. With a 10% target, SFF's false-alarm rate on successful episodes was 8.2 to 8.9% across suites, while its scores were still learning.

What comes next

Simulation lets us control every change and run every baseline on identical streams. The next step is a real arm, where conditions drift for real. Read about the SO-101 setup.