Moving On, Even When You're Broken: Fail-Active Trajectory Generation via Diffusion Policies Conditioned on Embodiment and Task

This paper introduces DEFT, a diffusion-based trajectory generator that enables robots to achieve fail-active operation by successfully completing tasks under arbitrary actuation failures, outperforming classical methods in both simulation and real-world scenarios while demonstrating robust zero-shot generalization.

The Gist

Imagine you are a robot. Your job is to move objects from point A to point B, like a human waiter carrying a tray or a construction worker moving bricks. But today, your body is broken. Maybe one of your "shoulders" (joints) is stuck and won't move. Maybe another "wrist" can only turn halfway. Maybe your "legs" are moving in slow motion.

In the old days, if a robot broke, the rule was simple: Stop immediately. Hit the emergency brake. Wait for a human to come fix you. This is called "fail-safe." It's safe, but it's also useless. If you're on Mars and your arm jams, you can't just sit there for years waiting for a repair crew. You need to keep working.

This paper introduces a new way of thinking called "Fail-Active." Instead of freezing, the robot says, "Okay, I'm broken, but I can still do the job. I just have to do it differently."

Here is how they did it, explained simply:

1. The Problem: The "One-Size-Fits-All" Plan Doesn't Work

Imagine you are trying to open a drawer.

• Normal You: You reach out, grab the handle, and pull. Easy.
• Broken You: Your right arm is locked straight. You can't reach the handle.

A traditional robot would look at its plan, realize "I can't reach," and say, "Error! Stopping."
A Fail-Active robot looks at the same situation and thinks, "I can't pull, but I can push. I'll push the drawer open instead."

The problem is that there are infinite ways a robot can break. You can't program a specific "Plan B" for every single broken joint combination. It's like trying to write a manual for every possible way a car can break down. It's impossible.

2. The Solution: DEFT (The "Adaptive Chef")

The authors created a system called DEFT. Think of DEFT as a super-smart, adaptive chef.

• The Ingredients (The Robot's Body): The chef knows exactly what ingredients (joints) are available. If the "left arm" is broken, the chef knows not to use that arm.
• The Order (The Task): The customer says, "I want a sandwich."
• The Magic: Instead of following a rigid recipe, the chef looks at the broken ingredients and instantly invents a new way to make the sandwich. Maybe they use their feet to hold the bread while their good hand slices the meat.

DEFT uses a type of AI called a Diffusion Model.

• The Analogy: Imagine a blurry photo of a robot moving. The AI slowly removes the blur, step-by-step, until a clear, perfect movement appears.
• The Twist: Before the AI starts "un-blurring," you tell it, "Hey, the robot's left leg is broken, and the goal is to push a box." The AI then "un-blurs" a movement that fits those specific broken legs and that specific goal. It generates a brand-new path on the fly.

3. How It Learned (The Training Camp)

To teach DEFT this skill, the researchers didn't just show it perfect robots. They broke the robots in the computer simulation thousands of times!

• They locked joints.
• They slowed down motors.
• They made the robot try to do tasks it couldn't normally do.

They taught the AI that "Broken" is just a new type of body. Just like a human can learn to write with their non-dominant hand if their dominant hand is hurt, the robot learns to move with its "broken" body.

4. The Results: Beating the Old Ways

The researchers tested DEFT in two ways:

1. In the Computer (Simulation): They broke the robot in 4,700 different ways.

   • Old Robots (Classical Methods): Only succeeded about 30-40% of the time. They got stuck and gave up.
   • DEFT: Succeeded 99.5% of the time for simple moves and 46% for hard, precise moves (which is huge, considering the robot was broken!).
   • The Analogy: If you asked a human to walk on a sprained ankle, they might limp but still get to the store. The old robot would just fall over. DEFT is the robot that keeps limping until it gets the job done.

2. In the Real World: They put a real robot arm in a lab and broke it.

   • Task 1: Open a drawer, put a block inside, and close it.
   • Task 2: Pick up an eraser and wipe a whiteboard clean.
   • Result: The old methods failed completely. DEFT did both tasks perfectly, even with a locked elbow and slow joints. It figured out how to push the drawer open because it couldn't pull it, and how to wipe the board without dropping the eraser.

The Big Takeaway

This paper is about resilience.

For a long time, we built robots that were fragile: "If you break, you stop."
This paper shows how to build robots that are adaptable: "If you break, you change your strategy."

It's the difference between a glass vase that shatters if you drop it, and a rubber ball that bounces back. DEFT gives robots the ability to bounce back, adapt to their injuries, and keep working without needing a human to come fix them. This is a giant step toward robots that can work on Mars, in disaster zones, or in our homes for years without needing a repair shop.

Technical Summary

Here is a detailed technical summary of the paper "Moving On, Even When You're Broken: Fail-Active Trajectory Generation via Diffusion Policies Conditioned on Embodiment and Task".

1. Problem Statement

Current robotic systems typically operate under a "fail-safe" paradigm: when a fault (e.g., a joint lock, reduced range of motion, or velocity limit) is detected, the robot halts immediately, requiring human intervention. This leads to significant downtime and reduced autonomy.

The paper addresses the challenge of Fail-Active Operation: enabling robots to continue functioning and completing tasks even when damaged. Specifically, the authors focus on actuation failures (joint range/velocity restrictions and locked joints). These failures fundamentally alter the robot's kinematics and feasible workspace, often rendering standard motion planning algorithms (like RRT or Inverse Kinematics) ineffective because they cannot adapt to the new, arbitrary "embodiment" of the robot. Existing solutions fail to generalize across arbitrary failure configurations, handle multiple manipulation primitives (e.g., switching from grasping to pushing), or manage multi-joint failures simultaneously.

2. Methodology: DEFT Framework

The authors propose DEFT (Diffusion-based Embodiment-aware Fail-active Task-conditioned trajectory generation), a framework that uses diffusion models to synthesize feasible joint-space trajectories conditioned on the robot's current degraded state and task requirements.

Core Architecture

DEFT formulates trajectory generation as a conditional diffusion process $\pi(Q_s, Q_g | \xi, \tau)$, where:

• $Q_s, Q_g$: Start and goal joint configurations.
• $\xi$ (Embodiment Encoding): A vector encoding per-joint failure constraints (minimum/maximum position and velocity limits). This allows the model to understand the specific "broken" state of the robot.
• $\tau$ (Constraint Encoding): A one-hot vector indicating the task primitive type (e.g., Unconstrained for free-space pick-and-place vs. Constrained for surface tracing or pushing).

Key Technical Components

1. Conditioning Mechanism:

   • The embodiment vector $\xi$ is processed through a Multi-Layer Perceptron (MLP) and injected into the diffusion model (UNet) via FiLM (Feature-wise Linear Modulation) layers. This allows the model to dynamically adjust its generation based on the specific joint limits.
   • The constraint vector $\tau$ is concatenated with the embodiment features to guide the model toward specific motion primitives.

2. Trajectory Inpainting and Clamping:

   • Start-Goal Inpainting: During the denoising process, the start ($Q_s$) and goal ($Q_g$) joint positions are fixed (inpainted) to ensure the trajectory connects the required states exactly.
   • Hard Constraint Enforcement: At every step of the denoising process, the predicted joint values are clamped to the limits defined by $\xi$. This ensures that the generated trajectory is physically feasible for the damaged robot, preventing the model from hallucinating impossible movements.

3. Data Generation:

   • The training dataset consists of joint-space trajectories generated under simulated failure conditions.
   • Failures are sampled stochastically (1 to 7 joints affected) with varying severity (locked, reduced range, reduced velocity).
   • Trajectories are generated for both Unconstrained (using RRT-Connect) and Constrained (using optimization-based IK with straight-line end-effector paths) primitives.

3. Key Contributions

1. Generalization to Arbitrary Failures: Unlike previous methods that require retraining or specific policy switching for known failure modes, DEFT generalizes to out-of-distribution (OOD) failure configurations it has never seen during training.
2. Multi-Primitive Capability: The framework handles both unconstrained (free motion) and constrained (contact-rich, straight-line) motions within a single unified policy, allowing the robot to switch strategies (e.g., from grasping to pushing) when a failure makes the original strategy impossible.
3. Robust Zero-Shot Adaptation: By conditioning on the embodiment vector, DEFT adapts to new failure states without fine-tuning or explicit replanning algorithms.
4. Real-World Validation: The system was successfully deployed on a 7-DoF Franka Emika Panda robot, demonstrating robust performance in complex, multi-step tasks under severe hardware degradation.

4. Experimental Results

Simulation Analysis

• Dataset: Evaluated on 4.7 million trajectories across 4,700 unique failure conditions (22% In-Distribution, 78% Out-of-Distribution).
• Performance:
  • Overall Success: DEFT achieved a 74.51% success rate in satisfying constraints, compared to 36.85% for classical baselines (RRT and Differential IK).
  • Unconstrained Motion: DEFT achieved 99.58% success vs. RRT's 42.4%.
  • Constrained Motion: DEFT achieved 46.42% success vs. Differential IK's 30.9%.
  • Generalization: Performance remained consistent between In-Distribution and Out-of-Distribution failures, proving the model learns the underlying physics of failure rather than memorizing specific cases.

Real-World Evaluation

The authors tested DEFT on a physical robot with induced joint failures on two long-horizon tasks:

1. Drawer Manipulation: Involves pulling a drawer, pushing an object, grasping, placing, and closing.
   • DEFT: 100% success rate (10/10 runs).
   • Optimization Baseline: 0% success (failed to find feasible plans).
   • DEFT-NoConditioning: 60% success (failed due to jerky motion and constraint violations).
2. Whiteboard Erasing: Involves grasping an eraser and performing constrained sweeping motions with a locked elbow joint.
   • DEFT: 100% success rate.
   • Optimization Baseline: 35% success (unstable contact).
   • DEFT-NoConditioning: 93% success (often lost control of the eraser due to lack of constraint awareness).

5. Significance

This work represents a paradigm shift from fail-safe (stop when broken) to fail-active (adapt and continue) robotics.

• Autonomy: It enables robots to operate in unstructured environments where hardware degradation is inevitable, reducing the need for human intervention.
• Scalability: By using diffusion models, the approach avoids the combinatorial explosion of training separate policies for every possible failure mode.
• Practicality: The successful real-world deployment demonstrates that generative AI can be used for robust, safety-critical control in physical systems, paving the way for more resilient autonomous agents in space exploration, manufacturing, and service robotics.

In conclusion, DEFT proves that by treating failure as a change in "embodiment" and conditioning a generative policy on this state, robots can dynamically reconfigure their behavior to complete complex tasks even when significantly damaged.