SFT can do more than expected in robotics.
PACER post-trains a VLA policy through SFT on its own rollouts, human corrections and supplementary clean demonstrations, weighting each valid action chunk in the native supervised action loss by how the attempt unfolded — not only by whether it succeeded.
teleoperated demonstrations for the initial policy
autonomous rollouts
plus ≤ human corrections per component, across collection configurations
components
/
held-out approach-and-handoff success: πθ0 → vanilla post-SFT → PACER
+ points over vanilla post-SFT
Motivation
Like a student after an exam, a robot policy learns most from what went well, what went wrong and what can be corrected. Its own rollouts and the human corrections that follow them record all three, yet a pass/fail label keeps almost none of it. Inspired by this, we explore the potential of supervised fine-tuning (SFT) to teach robots the way schools teach students: from the process of each attempt, not only its outcome. The video then shows how PACER does this and how it performs on the real robot.
Abstract
Robotic disassembly of end-of-life (EoL) products requires robots to accommodate product variation, follow prerequisite sequences, and approach components precisely for contact-rich manipulation. Supervised fine-tuning provides a practical path for adaptation, but limited and costly disassembly data cannot capture the distribution shifts arising from changing environments and product uncertainties. The policy’s own rollouts record its approach attempts, and human corrections demonstrate recovery from its errors, but turning these experiences into better policy performance remains challenging. We introduce PACER, a Process-Aware Correction and Evidence Reweighting framework that learns from these experiences through SFT, using progress toward the target and each trace’s source and outcome to weight valid action chunks in the native supervised action loss. PACER trains one policy per weighting setting and selects one of the resulting policies through held-out validation. We evaluate PACER on UR5e motherboard disassembly across five component classes, where it achieves / successful approach-and-handoff trials on the held-out benchmark, compared with / for vanilla post-SFT.
Idea
A supervised VLA’s rollouts are rarely a clean pass or fail. Some succeed (A), some stop just short of the target (B), some end in the wrong place (C), some fail outright (D). When a rollout goes wrong, an operator takes over and records a correction from that very state (E). What should each trace teach the next policy?
Three ways to learn from the same five traces.
Baseline
Learn from the outcome alone.
Diagram: traces B, C and D are discarded; A and E are used, with equal weight, to update the VLA.
Keeps successes and corrections and drops everything else. A near miss teaches nothing, and every kept trace counts the same.
Baseline
With an extra reward or value model.
Diagram: all five traces, A to E, go to a reward or value model fitted to this policy and task, which updates the VLA; the robot then rolls out the updated policy and collects new traces, in a loop. The same model does not fit another policy’s rollouts.
Adds a reward or value model, specified for the task and fitted to one policy’s own rollouts. Every update then requires repeated rollout-and-collect cycles on the robot.
Ours
Process matters: learn from process, not just outcome.
Diagram: all traces go both to process evidence and to an outcome gate. The gate passes A, E and B (as partial) and stops C and D, which are kept for audit with zero weight; process evidence scores each action chunk of A, B and E. Both set process-aware chunk weights for a native loss update of the VLA.
Keeps every trace. Outcome and safety labels decide what may be imitated (wrong-location endpoints count as failure labels); process evidence and trace roles then set a bounded weight for each valid action chunk in the native supervised action loss.
Method
PACER changes only how much each training row counts. The VLA backbone, its action head and its training objective stay exactly as they are. Select a step to find it in the figure.
The policy’s own attempts. Successes and near misses show which of its action chunks carried it towards the target.
Weight By process evidence, scaled by the role multiplier (lower for near misses than for successes). Wrong-location and wrong-region rollouts are gated to zero weight and kept for audit.
Recoveries an operator records from the state where a rollout went wrong. They teach what demonstrations cannot: how to get back from the policy’s own mistakes.
Weight By process evidence, scaled by the correction multiplier, with the floor fcorr = .
Complete demonstrations, recorded only for component-phase cells where the reference policy did not succeed in the initial rollout diagnostic, under a coverage rule fixed before the rollout campaign. They supply the nominal start-to-target path it has not learned there. They are separate from the initial supervised demonstrations, which are not replayed.
Weight By process evidence, with the higher floor fclean = , which anchors that path so reweighting cannot wash it out.
Neither human-recorded source suffices alone: the clean-only and correction-only baselines reach / and / held-out successes. PACER, which weights all three sources, reaches /.
Row weight
gi is the eligibility gate and sη the process score, centered by the median b and robust scale σ of its component-phase-role group; f is the protocol floor (fclean for clean rows, fcorr for correction rows, zero otherwise) and α the role multiplier. The final clip keeps every weight between zero and wmax.
Weighted native loss
The policy’s native per-horizon action loss ℓact, reweighted and normalized over each minibatch ℬ ⊂ 𝒟tr; the binary mask m keeps only valid horizons, dropping those without a finite in-bound target or after an unsafe event or manual stop.
Validation score
A component-balanced mean of row-level validation scores vj, computed from each fitted policy’s predicted chunks on logged validation observations. It ranks the weighting settings that pass both audits after training; no policy is trained against it.
Explainer
Illustrative traces, split into action chunks. Choose one of the predeclared weighting settings and switch the gate to see each chunk’s evidence turn into a weight.
Results
held-out trials per method: scene configurations × trials for each of the components, one close to the training distribution and one out of distribution, neither present in the initial demonstrations or the post-training data. A trial succeeds when the policy reaches a handoff state from which the fixed downstream skill can execute reliably.
Overall held-out successes per method. Baselines in neutral tones, PACER in teal.
Success rate per component, with Wilson intervals.
Policies trained from the same reference, each with trials on a mild and on a strong out-of-distribution configuration, distinct from the held-out benchmark. Gap: selected PACER minus each policy, with paired bootstrap % intervals.
Videos
Muted loops that play while on screen; each clip is marked with its playback speed.
Code
One repository, two layers, MIT-licensed.
PACER_Framework/
Robot- and VLA-agnostic: row schema, evidence functions, eligibility gates, η-weighted views, validation and adapter hooks.
pacer/ + scripts/
Data collection, rollout and correction helpers, action-chunk compilation, and weighting and validation helpers.
git clone --single-branch https://github.com/ChangChrisLiu/PACER.git
cd PACER/PACER_Framework
python -m pip install -e '.[dev]'
python -m pacer_framework.check_setup
python examples/end_to_end_demo.pyCite