A $300 3D-printed robot arm does not behave the same way twice. Its gears have play, which roboticists call backlash. Its hobby servos ignore small commands, a "deadband". Its tendons stretch and its plastic heats and flexes. A policy trained on demonstrations from a fresh arm slowly stops working as that arm wears, and it may never work on a neighbour's slightly different build. Today the standard fix is to collect new demonstrations and retrain the network. That costs teleoperation hardware, GPU time, and expertise, which are the very barriers low-cost robotics is trying to remove.
We propose a cheaper fix that works at deployment time. The robot keeps its demonstrations in memory. At each step it looks up the most similar remembered moments, the way nearest-neighbour methods do, and compares where the healthy demonstration arm actually went with where its own worn joints actually end up. It then learns a short, ordered list of if-then correction rules from these mismatches. An example rule would be: "when joint 2 has just reversed direction and the remembered demonstration is in its approach phase, add +1.4° to the command for the next 5 steps." The rules are picked one at a time, each chosen because it removes the most remaining error. This is the recipe of transformation-based learning, an old natural-language-processing technique that starts from a crude base prediction and greedily adds rules that fix its leftover mistakes. The result is a small "patch file" per physical arm. It is learned from minutes of autonomous rollouts on a laptop CPU, can be read and removed by a person, and can be shared alongside a base policy.
Core Claim
Hardware wear on cheap arms produces tracking errors that are sparse and depend on context. They cluster at direction reversals, near contact, and at particular joint configurations. We claim these errors are better handled by a greedily learned, ordered set of discrete correction rules than by retraining or by a dense learned residual network. The claim is specific to the low-data regime: a user can afford only a few minutes of rollouts on their own arm.
The memory is what makes the error signal available without labels. The retrieved demonstration states tell us where a healthy arm went from this situation. The worn arm's own position readback tells us where it went. The difference between them is a dense, self-supervised residual that the rule learner can work on.
Relation to Prior Work
The closest retrieval work is Difference-Aware Retrieval Policies for Imitation Learning (DARP). DARP keeps the expert dataset as a memory at test time. It feeds the difference between the query state and its nearest neighbours into a small network, and it reports 75% success on Robosuite Stack from image embeddings against 44% for behaviour cloning. DARP supplies our retrieval-and-difference machinery, which we reuse as the base system. It differs from our proposal in three ways. Its corrections are continuous and fixed at training time. It is evaluated only in simulation. It never models the gap between the demonstration hardware and the deployment hardware, which is our entire target.
On the rule-learning side, Brill's transformation-based tagger supplies the method: greedy, ordered, error-driven rule selection. It reached 97.2% on known words with only 267 rules. Two related works show that such rules can adapt a system without retraining it, which motivates our use of rules as a post-processing patch: Gao et al. apply them to segmentation standards and Carpuat et al. apply them as a corrector on top of classifiers.
Guideline Learning is the closest memory-plus-rules hybrid. It has a language model reflect on its extraction errors, write rules in natural language, and retrieve them at inference. That paper shows error-driven rule banks help in low-data regimes. However, its rules are text and are produced by a slow language-model call, so they cannot sit inside a 30 to 50 Hz control loop. Our rules are numeric predicates evaluated in microseconds.
On the hardware side, several papers motivate the problem without solving it. ALOHA/ACT and LeRobot make low-cost learning practical, but they absorb hardware quirks entirely into network weights and discard or ignore the demonstrations at run time. Morgan et al. show that compliance helps a great deal. Their results also constrain the claim that compliance alone suffices: success fell to near zero once visual feedback or in-hand routines were removed. AnyBody shows that monolithic multi-embodiment transformers collapse to near zero when extrapolating to new robot structures, which motivates local, per-arm correction.
One caution from Stanfill's memory-based pronunciation work shapes the design. Nearest-neighbour systems tolerate noisy inputs but are fragile to noisy targets. We therefore average the target over $k$ neighbours rather than trusting a single one.
Research Program
The base system is a DARP-style retrieval policy running on an arm whose joints have already been calibrated with a standard per-joint offset and deadband fit. That calibration serves as TBL's "initial state". At each control step $t$ we log two things. The first is the intended next joint position $\bar q_{t+1}$, taken as the average next state of the $k$ retrieved demonstration neighbours after shifting by the query difference. The second is the arm's measured position $q_{t+1}$. The residual is $e_t = \bar q_{t+1} - q_{t+1}$.
A rule $r = (\phi, j, \delta, m)$ has four parts. The trigger $\phi$ is a conjunction of discretized context features. These include the sign of each joint's recent velocity, whether a reversal occurred in the last few steps, the gripper state, a residual-magnitude bin, and the phase index of the retrieved demonstration. The phase index is where memory enters the rule language. The remaining parts are a joint $j$, an offset $\delta$ added to that joint's command, and a duration of $m$ steps. For each candidate trigger, $\delta$ is fit in closed form as the median residual over the steps where the trigger fires. Its first-order score is
$$\mathrm{gain}(r) = \sum_{t:\,\phi(x_t)} \big(|e_{t,j}| - |e_{t,j} - \delta|\big),$$
which counts the tracking error removed on the steps where the rule fires, minus the error it introduces there. Here $x_t$ is the context at step $t$.
Offline scoring on logged data cannot see how a rule changes the states that follow it. We therefore alternate two stages. First, the top few candidates by gain are proposed offline. Second, each is confirmed with short on-robot rollouts, and a rule is accepted only if measured tracking error falls and task success on a small validation set does not drop. Accepted rules are appended in order, and later rules condition on the arm's behaviour under earlier ones, as in Brill. This net-gain-plus-validation check is our answer to TBL's known over-correction problem.
We will build this on LeRobot. The patch file is a few kilobytes and is stored per arm, so it can be removed when a part is replaced or stacked as wear accumulates.
Baselines
The naive reference point is the base policy, trained on the healthy arm and run unchanged on the degraded arm. We run it both before and after per-joint calibration, which tells us how much of the damage is simple offset and deadband.
The strongest existing retrieval method is DARP. Its reported numbers are 75% success on Robosuite Stack from image embeddings, and 82% when combined with Diffusion Policy against 52% for Diffusion Policy alone (DARP). We use its published formulation with the same memory, neighbour count, and image encoder as our base system. On Push-T, no isolated DARP number was found on Lacuna. Diffusion Policy reports 95% on Push-T.
The strongest eager baseline is ACT, which reports 96% on ALOHA battery slotting (ALOHA). We fine-tune it on the degraded arm using as many human-teleoperated demonstrations as fit in the same wall-clock human time our method spends on supervised rollouts. On real SO-100 and Koch arms, no reported task-success result was found on Lacuna. LeRobot reports only throughput, a rise from 9 to 19 cubes per minute, so we will establish healthy-arm success ourselves.
The key competitor for the rule learner is a small learned residual network. It takes the same features and the same residuals and outputs a continuous per-joint offset. It is trained on exactly the same rollouts, with a hyperparameter search matched to the rule learner's validation budget.
Two ablations isolate the key ingredients. The first replaces the memory-derived target $\bar q_{t+1}$ with the policy's own commanded position, which removes the "compare against precedent" signal. The second removes the demonstration-phase feature from the triggers.
Beating the field means one of two outcomes. On the degraded arm, the patch recovers at least half of the success lost relative to the healthy arm, and does so beyond the calibrated DARP baseline. Alternatively, it matches the residual network while using fewer rollouts, and it does not degrade when its patch is transferred and then removed.
Why not just…?
Why not just fine-tune ACT or Diffusion Policy on the worn arm? This works if the user can collect fresh demonstrations. Doing so requires leader-arm teleoperation and GPU retraining every time wear changes. LIBERO also reports that naive pretraining can hurt downstream learning. Our matched-human-time comparison settles the question directly. If fine-tuning with equal human effort wins, our contribution narrows to the case where no leader arm is available.
Why not just learn a continuous residual network instead of discrete rules? This is the real threat. Our bet is that errors such as backlash, which fire only at reversals, are rare and sharply conditional. A dense network trained on a few minutes of data will smooth them away, while greedy net-gain selection isolates them. We test this by sweeping the rollout budget from 2 to 30 minutes and by reporting error separately at reversal steps and at other steps. If the network matches the rules at every budget, we will report that honestly. The remaining advantages would then be inspectability and the ability to remove a patch, which we measure directly but which are weaker claims.
Why not just calibrate backlash and deadband per joint, as classical control does? This is our starting point, not a rival. If the first few learned rules simply rediscover per-joint offsets, that is expected. The claim lives or dies on the gain from later, context-conditioned rules over the calibrated arm.
Why not just rely on compliance? Evidence from Morgan et al. shows that compliance without closed-loop correction collapses. In addition, compliance cannot correct systematic position offsets in free space.
Proposed Experiments
In simulation, we inject controlled hardware faults into Robosuite Stack and Push-T. The faults are per-joint backlash, deadband, gain mismatch, stiction, a gripper offset that depends on position (standing in for tendon stretch), and slow drift. Each fault is swept over severity, so we can trace success recovery curves against ground-truth fault parameters. We also check whether the learned rules actually localize at the injected faults.
On hardware, we use SO-100 and Koch arms through LeRobot. One healthy arm collects 50 demonstrations per task. Deliberately degraded copies are then used for deployment: loosened gear trains, a swapped servo, and a stretched gripper tendon. Each degraded arm is given a fixed budget of autonomous rollouts. We report task success, tracking error, the number of rules learned, and CPU latency. Rule evaluation should add negligible time beyond DARP's reported loop, which runs above 230 Hz.
Four checks are decisive. The first is the gain over the calibrated DARP baseline under reversal-heavy faults. The second is the comparison with the residual network at small rollout budgets. The third is the memory-target ablation. The fourth is a transfer-and-removal test: a patch learned on arm A should hurt arm B, and removing it after repair should restore baseline behaviour. A final cross-arm experiment uses a demonstration memory from one arm variant with a patch learned on another. It asks whether per-arm rule patches narrow the kind of extrapolation gap that AnyBody documents for monolithic models.
References
- Difference-Aware Retrieval Policies for Imitation Learning
- Some Advances in Transformation-Based Part of Speech Tagging
- Chinese Word Segmentation and Named Entity Recognition: A Pragmatic Approach
- A Stacked, Voted, Stacked Model for Named Entity Recognition
- Guideline Learning for In-Context Information Extraction
- Learning Fine-Grained Bimanual Manipulation with Low-Cost Hardware
- LeRobot: An Open-Source Library for End-to-End Robot Learning
- Vision-driven Compliant Manipulation for Reliable; High-Precision Assembly Tasks
- AnyBody: A Benchmark Suite for Cross-Embodiment Manipulation
- Memory-based Reasoning Applied to English Pronunciation
- Diffusion Policy: Visuomotor Policy Learning via Action Diffusion
- LIBERO: Benchmarking Knowledge Transfer for Lifelong Robot Learning