🤖 AI

TAM: Torque Adaptation Module for Robust Motion Transfer in Manipulation

The paper introduces the Torque Adaptation Module (TAM), a learned component that enables robust zero-shot transfer of dynamic manipulation policies across different robots and payloads by adapting torque commands based solely on proprioceptive history, thereby eliminating the need for policy-level domain randomization or real-robot data collection.

Original authors: Dongwon Son, Florian Shkurti, Jason Lee, Naman Shah, Beomjoon Kim, Dieter Fox

Published 2026-06-05

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Dongwon Son, Florian Shkurti, Jason Lee, Naman Shah, Beomjoon Kim, Dieter Fox

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a master chef who has spent years perfecting a recipe for a specific, high-end kitchen. This chef knows exactly how much pressure to apply to a knife, how fast to stir a pot, and how to handle a specific set of heavy, custom-made pans.

Now, imagine you want this chef to cook the exact same meal in a different kitchen. But this new kitchen has:

Slightly heavier pans (unknown payloads).
Knives that feel a bit "sticky" due to old grease (friction).
A stove that responds a tiny bit slower than the one the chef is used to (different dynamics).

If the chef tries to use their exact same movements without adjusting, the food might burn, the pan might slip, or the knife might not cut right. In robotics, this is the "Sim-to-Real" problem: a robot trained in a perfect computer simulation often fails when put on a real robot because the real world is messy, heavy, and unpredictable.

The Problem: The "Perfect" vs. The "Real"

The paper explains that existing solutions are like trying to teach the chef to be "super cautious" (Domain Randomization) so they can handle any kitchen, which makes them slow and clumsy. Or, you try to measure every single screw and spring in the new kitchen while the chef is cooking (System Identification), which takes too much time and data.

The Solution: TAM (The "Smart Adapter")

The authors introduce TAM (Torque Adaptation Module). Think of TAM as a super-smart sous-chef standing right next to the main chef, but only at the very last second before the knife hits the food.

Here is how TAM works, broken down into simple parts:

1. The "Black Box" Policy (The Chef)
The main robot policy (the "chef") is trained on a perfect, ideal robot. It sends out commands like "Move the arm to position X" or "Apply force Y." It doesn't know about the heavy pans or sticky grease.

2. The Low-Level Controller (The Arm)
This is the part that translates the chef's command into actual muscle movement (torque). It says, "Okay, to get to position X, I need to push with 10 Newtons of force."

3. TAM (The Sous-Chef)
TAM sits between the Low-Level Controller and the actual robot motor. It doesn't tell the chef what to do. It doesn't even know what the chef is trying to achieve (it doesn't see the recipe or the goal).

Instead, TAM watches the robot's history. It looks at:

How the arm actually moved in the last few seconds.
How much force was actually applied.
How the arm felt (proprioception).

Based on this history, TAM realizes, "Hey, the arm is moving slower than it should because of that heavy pan."

4. The Magic Adjustment (The Residual Torque)
TAM calculates a tiny, instant correction. If the controller said "Push with 10 Newtons," TAM might whisper, "Actually, push with 10.5 Newtons to compensate for the friction." It adds this tiny "extra push" (residual torque) to the command right before it hits the motor.

Why is this special?

It's Plug-and-Play: You can take a robot policy trained for one job (like pushing a box) and another trained for a totally different job (like flipping a cube), and TAM works for both. You don't need to retrain the main chef. You just plug in the TAM adapter.
It Learns from "Feel," Not "Sight": TAM doesn't need to see the robot's camera or know the task. It only needs to feel the robot's history. It's like a blindfolded expert who can tell if a car is heavy just by how the engine sounds and how the steering wheel vibrates.
It's Fast: TAM makes these tiny adjustments 1,000 times a second (1 kHz). This is fast enough to handle dynamic, fast-moving tasks like flipping objects or balancing a ball, which slower methods can't do.
It Needs No Real-World Data: The "sous-chef" (TAM) is trained entirely in a computer simulation with thousands of random "what-if" scenarios (heavy pans, sticky grease, broken springs). Once trained, it can be dropped onto a real robot and work immediately, even if the robot has a completely unknown weight attached to it.

The Results

The paper tested this on a real robot (a Franka Panda) with three very different tasks:

Pushing a box (using a policy learned by Reinforcement Learning).
Flipping a cube (using a policy learned by copying human demonstrations).
Balancing a ball on a plate (using a math-based controller).

In all cases, the robot with TAM performed much better than robots that tried to guess the physics on the fly or robots that just tried to be "cautious." TAM allowed the robot to move with the same confidence and speed as if it were in the perfect simulation, even though it was dealing with real-world messiness.

Summary Analogy

If the robot policy is a driver who learned to drive on a perfect, dry race track, and the real world is a rainy, muddy road:

Old methods tell the driver to drive super slowly and carefully (conservative).
Other methods try to measure the mud depth while driving (slow and complex).
TAM is like a co-pilot who feels the car slipping and instantly tweaks the steering and gas pedal 1,000 times a second to keep the car on the track, without ever needing to tell the driver to change their driving style.

The paper concludes that TAM is a robust, flexible tool that lets robots trained in the "perfect world" of simulation succeed in the "messy world" of reality, without needing to be retrained for every new robot or every new heavy object they might pick up.

Technical Summary: Torque Adaptation Module (TAM) for Robust Motion Transfer in Manipulation

1. Problem Definition

The paper addresses the challenge of sim-to-real transfer and motion robustness in robotic manipulation. A policy trained or designed for a specific "ideal" robot model often fails when deployed on a target robot with differing dynamics. These discrepancies arise from:

The sim-to-real gap (unmodeled friction, damping, actuator delays).
Unknown payloads (added mass and center-of-mass shifts).
Instance-to-instance variations (manufacturing tolerances).

In contact-rich, dynamic tasks, even small motion discrepancies disrupt contact timing and modes, leading to task failure. Existing solutions face significant limitations:

System Identification (SysID): Requires continuous data collection and model re-identification for every new robot or payload change.
Domain Randomization: Often produces overly conservative policies that fail to exploit the full dynamic range of the robot.
Policy-Side Adaptation (e.g., RMA, UPOSI): Requires retraining or distilling the policy with an adaptation branch, which is costly or impossible for closed-source, third-party, or model-based (MPC) policies.

2. Methodology: The Torque Adaptation Module (TAM)

The authors propose TAM, a learned module inserted at the torque interface—between the low-level controller and the robot's physical actuators. TAM operates independently of the high-level policy, allowing it to adapt any existing policy (RL, BC, or MPC) without modifying the policy itself.

Core Architecture

TAM consists of two primary components operating at different time scales:

History Encoder (5 Hz):
- Input: A long-horizon history (12 seconds) of proprioceptive data (joint positions $q$ , velocities $\dot{q}$ ) and applied torques $\tau^a$ .
- Feature Augmentation: The encoder incorporates a physics residual feature ( $e_\tau$ ), calculated as the difference between the applied torque and the torque the ideal model would require for the observed motion. This provides a direct signal of dynamics mismatch.
- Processing: Uses a patch-wise time-series tokenization strategy with a causal Transformer to efficiently process the high-frequency (1 kHz) history into a compact latent state $z_t$ .
Torque Adaptor (1 kHz):
- Input: The latent state $z_t$ , a short local window of recent state/torque, and the nominal torque $\tau^0_t$ generated by the low-level controller.
- Output: A residual torque correction $\Delta\tau_t$ .
- Mechanism: Uses adaptive layer normalization conditioned on $z_t$ to allow the same weights to express different correction laws for different dynamics.
- Final Command: The corrected torque $\tau^c_t = \text{clip}(\tau^0_t + \Delta\tau_t)$ is sent to the robot.

Training Strategy

Task-Agnostic Data: TAM is trained on randomized, free-space joint-motion rollouts, not specific task demonstrations.
Supervision: The training objective is local torque matching. Given a state and a nominal torque, the system calculates the "teacher" torque required for the perturbed (target) robot to achieve the same acceleration as the ideal robot.
Two-Stage Pipeline:
1. Multi-Robot Pretraining: The module is trained on randomized rollouts from five different robot models (Panda, Piper, RBY-1, iiwa14, Flexiv Rizon4) to learn a shared correction initialization.
2. Robot-Specific Fine-tuning: If a simulator for the target robot is available, the pre-trained weights are fine-tuned on that robot's randomized rollouts. No real-world data is required for this step.

3. Key Contributions

Decoupled Adaptation: By moving the adaptation layer to the torque interface, TAM does not require access to policy observations, rewards, or internal states. This enables the reuse of a single set of TAM weights across diverse policies (RL, BC, MPC) and action spaces (joint targets, end-effector targets, direct torques).
Zero-Shot Real-World Transfer: The method enables robust execution on real robots with unknown payloads and dynamics without retraining the underlying policy or collecting real-world calibration data.
High-Frequency Correction: Operating at 1 kHz, TAM supports fast, dynamic manipulation tasks that require rapid response to contact and inertia changes.
Generalization: The multi-robot pretraining approach allows the module to generalize to unseen robot morphologies, with further improvements possible via simulation fine-tuning.

4. Experimental Results

The authors evaluated TAM on a real Franka Emika Panda robot across three distinct tasks and a simulated cross-robot tracking study.

Real-World Tasks (Franka Panda)

Vision-Based RL Box Pushing: TAM achieved a 76.2% success rate, significantly outperforming Direct execution (47.6%) and Online System Identification (57.1%).
Behavior-Cloned Cube Flip: TAM achieved 72.0% success, nearly matching the ideal simulation baseline (73.5%) and more than doubling the success rate of Online SysID (34.0%).
MPC Ball-on-Plate Balancing: TAM completed 13.6 ± 2.9 goals in 15 seconds, outperforming Online SysID (13.1) and Direct execution (8.8), approaching the ideal simulation performance (15.9).
Tracking with Unknown Payloads: In end-effector tracking tasks with a hidden 1 kg payload, TAM reduced tracking error (RMSE) from ~6 cm (Direct) to 1.29 cm (Carried state), outperforming explicit parameter estimation baselines.

Simulation Cross-Robot Generalization

TAM weights pre-trained on five robots were tested on two unseen robots (Google Robot, Unitree Z1).
The multi-robot pre-trained TAM reduced tracking error significantly compared to Direct and Online SysID baselines.
Fine-tuning on the target robot's simulation further reduced error, demonstrating the efficacy of the two-stage training pipeline.

Ablation Studies

History Encoder: Removing the long-horizon encoder reduced success rates significantly (from 84% to 42% in simulation), highlighting the importance of temporal context.
Physics Residual Feature: Removing the $e_\tau$ feature weakened cross-robot transfer, confirming its role in generalizing beyond specific morphologies.
Direct Torque vs. Parameter Prediction: Directly predicting residual torque outperformed methods that attempted to predict explicit physical parameters first.

5. Significance and Claims

The paper claims that TAM represents a shift in how sim-to-real transfer is handled for manipulation. Instead of forcing the policy to learn robustness or requiring continuous system identification, TAM offloads the adaptation burden to a modular, torque-level interface.

Modularity: It allows "plug-and-play" adaptation for independently authored policies (RL, BC, MPC) without retraining.
Efficiency: It eliminates the need for real-world data collection for adaptation, relying instead on randomized simulation and multi-robot pretraining.
Robustness: It enables dynamic, contact-rich manipulation on real hardware with unknown physical parameters, achieving performance close to ideal simulation baselines where traditional methods fail.

The authors acknowledge limitations: TAM requires access to a torque interface and matched kinematic structure. It assumes the target robot's dynamics can be corrected within the actuator's torque budget and does not provide formal guarantees for long-horizon stability or tasks requiring dynamics outside the training distribution (e.g., extreme contact forces not seen in training).