💻 computer science

I-FailSense: Towards General Robotic Failure Detection with Vision-Language Models

The paper introduces I-FailSense, an open-source vision-language model framework that detects semantic misalignment errors in robotic manipulation through a specialized post-training and ensembling approach, demonstrating superior performance and strong generalization to diverse failure types and environments.

Original authors: Clemence Grislain, Hamed Rahimi, Olivier Sigaud, Mohamed Chetouani

Published 2026-02-20

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Clemence Grislain, Hamed Rahimi, Olivier Sigaud, Mohamed Chetouani

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

🤖 The Big Problem: Robots That Can't Admit They're Wrong

Imagine you hire a very smart, highly trained robot assistant to help you in your kitchen. You give it a simple instruction: "Put the blue block on the table."

The robot picks up a block and puts it on the table.

Scenario A (Success): It picks up the blue block. ✅
Scenario B (Control Error): It tries to pick up the blue block, but its gripper slips, and the block falls on the floor. ❌
Scenario C (The Hidden Trap): It picks up the red block and puts it on the table. It looks like it's working hard, and the block is on the table, but it did the wrong thing. ❌

Current robots are getting better at Scenario A. They are also getting okay at spotting Scenario B (the physical slip-ups). But they are terrible at Scenario C. They think, "I put a block on the table! Mission accomplished!" They don't realize they misunderstood the specific instruction.

This is called a Semantic Misalignment Error. The robot is doing something meaningful, but it's not what you asked for.

🧠 The Solution: I-FailSense

The researchers at Sorbonne University created a new system called I-FailSense. Think of it as giving the robot a "Self-Check Mirror" that it can look into after every action to ask, "Did I actually do what you asked?"

Here is how they built it, broken down into three simple steps:

1. Building the "Wrong Answer" Library 📚

To teach a robot to spot mistakes, you can't just show it perfect examples. You have to show it examples of things going wrong.

The Analogy: Imagine a teacher trying to teach a student to spot spelling errors. If the teacher only shows the student perfect essays, the student won't know what a typo looks like.
The Paper's Trick: The researchers took existing datasets of robots doing tasks perfectly. Then, they used a computer program to "swap" the instructions. They took a video of a robot lifting a blue block and labeled it with the instruction "Lift the red block."
Result: They created a massive library of "tricky" examples where the robot looks like it's working, but it's actually following the wrong script. This is the Semantic Misalignment Dataset.

2. The Two-Stage Training Camp 🏋️

They didn't just throw the robot into the deep end. They used a two-step training process using a large AI model (called a Vision-Language Model or VLM).

Stage 1: The "LoRA" Tuning (The Generalist)
- Analogy: Think of the base AI as a university student who knows a lot about the world but hasn't studied "Robot Safety" yet.
- Action: They gave the student a "cheat sheet" (called LoRA adapters) that helps them focus specifically on the connection between what they see and what they are told. They didn't retrain the whole student; they just added a few specialized notes to their brain.
Stage 2: The "FS Blocks" (The Specialized Judges)
- Analogy: Imagine the student's brain has different layers of thinking. The bottom layer sees pixels (colors/shapes). The middle layer sees objects (blocks/tables). The top layer understands complex logic.
- Action: The researchers attached tiny "judges" (called FS Blocks) to these different layers.
  - The Bottom Judge asks: "Do the colors match?"
  - The Middle Judge asks: "Is the robot holding the right object?"
  - The Top Judge asks: "Does the whole story make sense?"
- The Voting: At the end, all these judges vote. If the Top Judge says "Success" but the Middle Judge says "Failure," the system listens to the group. This "committee" approach makes the decision much more robust.

🚀 The Amazing Results

The researchers tested I-FailSense in three ways, and it crushed the competition:

The Tricky Test (Semantic Errors):
- When asked to spot the "Red vs. Blue" mistakes, I-FailSense got 90% accuracy.
- The best "off-the-shelf" robots (like GPT-4o or Qwen) only got about 60-70%. They were often fooled by the robot's confident-looking but wrong actions.
The "Surprise" Test (Control Errors):
- They tested it on a dataset where robots dropped things or slipped (Control Errors), which the robot was never explicitly trained on.
- The Magic: Because I-FailSense learned to pay close attention to whether the robot's motion matched the words, it accidentally got really good at spotting physical slips too. It generalized to this new problem with 89% accuracy, beating models that were specifically trained on those errors.
The Real World Test (Sim-to-Real):
- They trained the robot in a video game (simulation) and then tested it in the real world with a real robot arm.
- Usually, robots trained in games fail miserably in the real world because of lighting, shadows, and messy backgrounds.
- The Result: With just a tiny bit of extra tuning, I-FailSense transferred to the real world and achieved 74% accuracy. It could look at a real video of a robot failing and say, "Hey, that's not what you asked for!"

💡 Why This Matters

Most robots today are like blind followers. They do what they are told, but if they misunderstand, they keep going, wasting time and potentially breaking things.

I-FailSense turns the robot into a critical thinker. It gives the robot the ability to:

Listen to the instruction.
Watch its own actions.
Compare the two.
Realize, "Wait, I'm holding the wrong block!"

This is a huge step toward robots that can work safely in our homes and factories without needing a human to watch over their shoulder every second. It's the first step toward robots that can learn from their own mistakes, just like humans do.

1. Problem Statement

The paper addresses a critical gap in robotic autonomy: the ability of robots to autonomously detect their own failures in open-world settings without relying on external supervision.

The Core Challenge: While Vision-Language Models (VLMs) have improved spatial reasoning and task planning, they struggle to recognize when a robot has failed.
Specific Focus: The authors distinguish between two types of failures:
1. Control Errors: Low-level physical mistakes (e.g., dropping an object, failing to grasp). These are often detectable via visual cues alone.
2. Semantic Misalignment Errors: High-level errors where the robot executes a semantically meaningful action that contradicts the language instruction (e.g., lifting a red block when instructed to lift a blue block, or rotating an object in the wrong direction).
The Gap: Existing VLMs and failure detection benchmarks (like AHA) primarily focus on control errors. Semantic misalignment errors are underexplored because they require deep language grounding across both spatial and temporal dimensions of a robot's trajectory.

2. Methodology: I-FailSense

The authors propose I-FailSense, a framework designed to detect failures by leveraging the internal representations of a pre-trained VLM. The system operates on a trajectory of observations ( $\tau$ ) and a textual instruction ( $g$ ) to output a binary success/failure prediction.

A. Dataset Construction (Semantic Misalignment Failure Datasets)

To train the model, the authors created a novel dataset construction pipeline ( $D_{SMF}$ ) from existing expert demonstration datasets (e.g., CALVIN, DROID):

Positive Examples: Expert trajectories paired with their correct original instructions.
Negative Examples (Semantic Misalignment): Expert trajectories are paired with incorrect instructions from the same task category (e.g., swapping "lift blue block" with "lift red block"). This creates subtle, challenging negative examples where the robot's behavior is physically valid but semantically wrong.

B. Model Architecture

I-FailSense is built upon the PaliGemma2-mix-3B VLM and utilizes a two-stage post-training pipeline:

Stage 1: Parameter-Efficient Fine-Tuning (PEFT):
- The base VLM is fine-tuned using LoRA (Low-Rank Adaptation) on the language model's KQV projection layers and the projection MLP.
- The vision encoder (SigLIP) remains frozen.
- This stage adapts the model to the failure detection task while preserving general knowledge.
Stage 2: Grounded Arbitration (FS Blocks):
- Instead of relying solely on the VLM's final output, the authors attach lightweight binary classification heads called FailSense (FS) blocks to multiple intermediate layers ( $K$ layers) of the VLM.
- FS Block Architecture: Each block uses a hybrid attention pooling mechanism (MLP + Multi-Head Attention) followed by residual MLPs to process features from a specific depth of the VLM.
- Ensembling/Voting: During inference, predictions from all $K$ FS blocks and the original VLM output are aggregated using a weighted voting mechanism. This allows the system to leverage different levels of reasoning abstraction (from low-level features to high-level semantics) for robust decision-making.

3. Key Contributions

New Dataset Paradigm: Introduction of a method to generate Semantic Misalignment Failure datasets from existing benchmarks, addressing a previously underexplored failure mode.
I-FailSense Framework: A novel architecture that decouples the generative power of a foundation VLM from a dedicated, trainable classification head, utilizing multi-layer feature aggregation for failure detection.
Generalization Capability: Demonstration that training specifically on semantic misalignment errors enables the model to generalize to control errors and out-of-distribution (OOD) environments without explicit retraining on those specific error types.
Sim-to-Real Transfer: Successful transfer of the model to real-world robotic data with minimal fine-tuning.

4. Experimental Results

The authors evaluated I-FailSense on simulated (CALVIN, RLBench/AHA) and real-world (DROID) datasets.

Semantic Misalignment Detection (In-Distribution):
- On the DSMF-CALVIN dataset, I-FailSense achieved 90.6% accuracy (single camera view) and 88.2% (dual view).
- This significantly outperformed zero-shot SOTA VLMs (GPT-4o, Qwen2.5-VL-7B, PaliGemma2), which struggled with precision on subtle semantic errors.
Generalization to Control Errors (Out-of-Distribution):
- Tested on the AHA dataset (which contains ~85% control errors and ~15% semantic errors).
- I-FailSense, trained only on semantic misalignment, achieved 89% accuracy, surpassing the AHA baseline models (trained directly on AHA data) by +19 percentage points.
- Insight: Learning to align language with motion for semantic errors inherently teaches the model to detect when motion fails to match instructions (control errors).
Generalization to New Simulations:
- The model generalized from the CALVIN environment to the RLBench environment (different objects, camera setups) with high accuracy, proving robustness to environmental shifts.
Real-World Transfer (Sim-to-Real):
- On the DSMF-DROID (real-world) dataset, a model trained solely on simulation data showed a drop in recall.
- However, minimal fine-tuning of the FS blocks on real-world data (or a mix of sim and real) restored performance, achieving 74% accuracy.
- Notably, the real-world model performed better with dual camera views (exocentric + egocentric) compared to single views, likely due to the complexity and distractors in real-world scenes.

5. Significance and Conclusion

Autonomous Self-Correction: I-FailSense provides a pathway for robots to evaluate their own performance, a prerequisite for learning from failure and robust deployment in unstructured environments.
Efficiency: The approach is highly parameter-efficient, using a 3B parameter model to outperform much larger models (e.g., GPT-4o) and specialized baselines.
Unified Detection: The work demonstrates that semantic misalignment is a "super-task" for failure detection; mastering it provides the necessary grounding to detect a broader spectrum of robotic failures, including physical control errors.
Future Impact: This framework lays the groundwork for future systems where robots can not only detect errors but also trigger recovery mechanisms or adapt their policies autonomously.

In summary, I-FailSense represents a significant step forward in robotic intelligence by moving beyond simple physical failure detection to understanding the semantic alignment between instructions and actions, enabling robust, generalizable, and self-aware robotic agents.