Federate the Plan, Keep the Compliance Local

Robots in different factories or clinics could learn a shared manipulation skill without pooling their camera and force logs. Federated learning does this by sending the model to each robot, training locally, and averaging the updates on a server. The largest benchmark of this idea for manipulation, FLAME, shows that the approach breaks where it matters most. Its federated policies close a box 84–86% of the time. They reach 0% success on peg insertion and on scooping with a spatula, under every aggregation rule tested. Those policies output raw joint positions. On a tight-tolerance task, a millimetre of misalignment becomes a jam. Each simulated client also has different friction, mass and appearance, so each one "wants" a slightly different trajectory, and averaging those wishes produces a policy that fits none of them.

We propose to change what the robots learn and share, and to leave the averaging rule alone. Each robot runs an admittance controller: a software layer that makes a stiff arm behave like a mass on a spring and damper, so that contact forces push it off its planned path instead of fighting it. The federated policy then outputs a target pose, a target contact force and the spring and damper settings. The claim is that this action space moves most of the physical differences between robots out of the shared network and into a small set of compliance settings. Those settings are then learned locally on each robot, with a shared prior. In two sentences: federated manipulation fails on contact tasks because the shared model is forced to encode each site's physics. Letting a compliance layer absorb that physics, and personalizing only its gains, should make federated training nearly as good as pooling the data.

Core Claim

Admittance control makes the robot's deviation $\Delta x$ from its nominal path obey $M\Delta\ddot{x} + D\Delta\dot{x} + K\Delta x = F_{\text{ext}}$. Here $M$, $D$ and $K$ are the virtual mass, damping and stiffness matrices, and $F_{\text{ext}}$ is the measured contact force. Our policy has two parts that are treated differently under federation. The first is a shared planner $\pi_\theta$. It maps images, proprioception and a short force history to a target pose and target force. Its weights $\theta$ are averaged across robots. The second is a small per-robot gain head $g_{\phi_k}$. It maps the recent force and velocity history to diagonal gains through a log parameterization,

$$K_k = \mathrm{diag}\big(\exp(g^{K}_{\phi_k})\big), \quad D_k = \mathrm{diag}\big(\exp(g^{D}_{\phi_k})\big), \quad M_k = \mathrm{diag}\big(\exp(g^{M}_{\phi_k})\big),$$

where $k$ indexes the robot (client) and $\phi_k$ are its local head weights. The gains are therefore always positive, so each client's linear admittance system is passive whatever weights come out of training. The server keeps a prior $\bar\phi$, the average of the $\phi_k$. A new robot starts from this prior, and each robot's local training is pulled gently toward it.

The testable claim concerns heterogeneity, not a new aggregator. Measure how much robots' updates disagree: take the average cosine similarity between each client's update to $\theta$ and the mean update. We predict this disagreement is substantially smaller when $\pi_\theta$ plans in the admittance action space than in FLAME's kinematic space. We also predict that the gap between federated and pooled (centralized) training shrinks to match. If neither prediction holds, the thesis is wrong, even if success rates rise for other reasons.

The positivity parameterization matters as a constraint, not as a contribution. FLAME's authors call for "physics-aware aggregation." When gains are exponentiated outputs, though, plain averaging already cannot produce a non-passive controller, so no special aggregator is needed for that. We say so plainly rather than dress up a trivial property as a method.

Relation to Prior Work

Two results motivate the proposal. FLAME establishes the failure. It benchmarks FedAvg, FedAvgM (FedAvg with server-side momentum), FedOpt (adaptive server optimizers such as FedAdam) and Krum (a rule that keeps the client update closest to the others and discards outliers). All four run on RLBench-based clients with purely kinematic actions. FLAME also reports that offline action error does not predict closed-loop success, and that more than about 25 local epochs causes client overfitting. Federated Joint Learning of Robot Networks in Stroke Rehabilitation federates simulated Jaco arms across hospital silos. Its authors name the missing contact forces and patient resistance as its main limitation. Neither work gives clients any compliance, so neither can tell whether the failure comes from the action space or from federation itself.

Three lines of work supply the mechanism. AdmitDiff trains a diffusion policy, a generator that turns noise into action sequences step by step, to output poses and target forces for an admittance controller. It reports 15.3% higher success and 48.8% lower contact force, but it hand-tunes the gains per task and trains on one robot. Variable impedance control as an RL action space shows that predicting stiffness and damping as actions speeds learning and transfers from simulation to reality. Buchli et al. and Okada et al. show that good stiffness schedules are low during approach and high in contact. That suggests the gain head needs little capacity. We reuse the AdmitDiff-style action space and the gains-as-actions idea. Our addition is to split them across the federation boundary.

Two works constrain the design. ILC-MBK tunes admittance gains on a single UR5 by iterative learning over repeated trials: a 98.21% RMSE improvement over fixed gains, but over 750 trials on one robot. This is exactly the per-robot alternative we must beat on how many trials a new robot needs. The stability analyses of asymmetric stiffness and passivity-based nonlinear admittance are why we restrict gains to positive diagonal matrices. We give up off-diagonal coupling to keep a stability guarantee that survives averaging. FAVLA points to a separate issue: vision runs at 15–30 Hz while force control needs about 1 kHz. Our split matches that separation, with a slow shared planner and a fast local admittance loop and gain head. We do not federate anything that runs at the fast rate.

Research Program

The testbed extends FLAME's RLBench/CoppeliaSim clients. We target the four FLAME tasks, with the two high-precision ones as the focus. We define client heterogeneity along THE COLOSSEUM axes, with physical-property perturbations (object mass, surface friction) as the primary axis and visual perturbations as a secondary one. COLOSSEUM reports 30–50% drops for single perturbations and over 75% failure under compound ones. Its sim-to-real correlation of $R^2 = 0.614$ gives modest assurance that simulated trends carry over to the physical Panda.

FLAME's demonstrations are kinematic, so we must regenerate them. We will replay RLBench's waypoint planner through a simulated admittance controller, reading contact force from joint-torque estimates or an added wrist force-torque sensor. We will record the resulting poses and contact forces as targets, and collect gain labels by a per-environment gain sweep. Building this force-annotated version of the FLAME client set is itself a deliverable. It is also the main engineering risk: CoppeliaSim contact is stiff and can be noisy. We will therefore first verify that a centrally trained admittance policy clears the insertion task at all before running any federated comparison.

Federated training uses Flower (the library FLAME uses), 25 local epochs following FLAME's ablation, and FedAvg for the shared planner. The gain head trains locally with a proximal pull toward $\bar\phi$. Analysis has two parts. The first is the update-disagreement measurement described above, tracked across rounds for kinematic and admittance action spaces under matched heterogeneity. The second is a sweep of heterogeneity strength: friction and mass ranges from narrow to COLOSSEUM-compound. For each baseline we plot how the federated-minus-centralized gap grows with that strength.

Baselines

The naive reference is FLAME's own setup: a kinematic convolutional-plus-MLP policy trained with FedAvg, FedOpt and Krum, re-run on our client split with the same demonstrations, rounds and tuning budget. The strongest reported numbers are from FLAME. Success is 0% on Insert Onto Square Peg and Scoop With Spatula for all four aggregators, 28% on Slide Block with FedOpt, and 86% on Close Box with Krum (84% with FedAvg). There is no reported result on Lacuna for any admittance-controlled policy on the FLAME tasks, so our re-run of FLAME is the anchor. Beating it means clearly non-zero insertion and scoop success without losing Close Box performance.

The strongest competitor, and the ablation that isolates our key ingredient, is fixed-gain admittance under full FedAvg. It uses the same planner and action space, but with one hand-tuned gain set shared by all clients, as in AdmitDiff. The gains get the same tuning budget as our method's hyperparameters. Beyond this we run two further variants. The first federates the gain head too, with no personalization. The second replaces the gain head with a generic local head of equal size that outputs unconstrained residual actions. This last variant separates "any personalization helps" from "personalizing compliance helps." Our method beats these only if it wins on the high-precision tasks under strong physical heterogeneity. It must also cut peak contact force, and the margin must grow with heterogeneity strength.

The upper reference is centralized pooled training of the identical admittance policy. The lower one is local-only training on each client's data. We also run a per-robot iterative-learning baseline in the style of ILC-MBK. A federated planner with fixed initial gains is deployed, and each client tunes its gains by trial repetition. We compare its success after $n$ trials with our prior-initialized gain head after the same $n$ trials on held-out clients.

Why not just…?

Why not just put a fixed admittance controller under the federated policy? This is the real threat. It may recover much of the insertion failure by itself, since AdmitDiff's gains came from a fixed-gain design. If it matches our method across the heterogeneity sweep, the personalization claim is refuted. The remaining finding would still be worth publishing: the action space, not the aggregator, explains FLAME's 0%. The heterogeneity sweep settles this. We expect fixed gains to hold up under narrow friction ranges and degrade under COLOSSEUM-compound physical shifts, where one stiffness cannot suit both slippery and sticky sites.

Why not just centralize the data with heavy domain randomization? Where privacy allows it, one should. We include pooled training as the upper bound, not as a rival. The federated question matters where logs cannot move: hospitals, as in FJL, or proprietary cells. There, the relevant measure is how close federated training gets to pooled. COLOSSEUM's 30–50% drops for centrally trained, non-compliant policies suggest randomization alone does not solve contact shifts, but our pooled admittance run tests this directly.

Why not just tune gains on each robot with iterative learning? ILC-MBK shows this works very well locally. It also took 750 trials on one task and one robot, and it does not learn visual skills that transfer across tasks. The trial-budget comparison on held-out clients decides whether a federated prior is worth anything. If per-robot tuning reaches equal success within a few dozen trials, the shared prior adds little, and we will say so.

Why not just use a generic personalized-federated-learning split, keeping the last layer local? Such splits could capture site-specific physics without any control structure. The equal-capacity unconstrained local head tests exactly this. Our prediction is that it overfits local quirks, as FLAME saw with long local training, and gives no stability guarantee. If it matches the gain head, the physical structure of the split adds nothing beyond parameter count.

Proposed Experiments and Decisive Checks

We run three checks, in order, and each can stop the project. The first is feasibility. A centrally trained admittance policy must achieve non-trivial Insert Onto Square Peg success in our regenerated RLBench setting. If it cannot, the simulator, not federation, is the bottleneck, and we move to a real two-arm setup before continuing. The second is the mechanism check. Under matched heterogeneity, client-update disagreement and the federated-minus-centralized gap must both be smaller for the admittance action space than the kinematic one. This must hold with fixed gains, before any personalization. The third is the personalization check. Across the friction-and-mass sweep, the local gain head must beat fixed-gain FedAvg, the federated gain head and the generic local head on high-precision success and peak contact force, with the advantage widening as heterogeneity grows. On held-out clients, the prior-initialized gain head should reach a target success rate in fewer trials than per-robot iterative tuning.

We report task success over at least 50 seeded rollouts per test environment, peak and mean contact force, the fraction of rollouts with force above a damage threshold, and communication per round. Communication should be unchanged relative to FLAME, since the gain head never leaves the robot. Optionally, we will replicate the fixed-versus-personalized comparison on two physical arms with differently compliant work surfaces, using a pose-and-force-and-gain action space like AdmitDiff's. That would test whether the simulated trend survives real contact.