ReViP: Mitigating False Completion in Vision-Language-Action Models with Vision-Proprioception Rebalance

This paper introduces ReViP, a novel Vision-Language-Action framework that mitigates "false completion" failures caused by proprioceptive bias through vision-proprioception rebalancing and a new benchmark suite, achieving significant performance gains over existing models.

The Gist

Imagine you are teaching a robot to make a sandwich. You tell it, "Pick up the bread, put it on the plate, and then grab the cheese."

In the world of advanced robotics, these robots use Vision-Language-Action (VLA) models. Think of these models as a robot's brain that combines three things:

1. Eyes (Vision): What it sees.
2. Voice (Language): What you told it to do.
3. Muscle Memory (Proprioception): How its joints feel and where its arms are currently positioned.

The Problem: The Robot's "Denial"

The paper identifies a funny but frustrating problem called "False Completion."

Imagine the robot is holding a piece of cheese. Suddenly, it slips out of the gripper and falls onto the floor.

• What a human does: "Oh no, the cheese fell! I need to pick it up again."
• What the old robot does: It ignores the cheese on the floor. Why? Because its "muscle memory" (proprioception) is telling it, "I am currently in the 'holding cheese' phase of my plan." It trusts its internal plan more than its eyes. So, it continues moving its arm toward the plate, pretending it's still holding the cheese, and then declares, "Task Complete!"

The robot has falsely completed the task. It's like a student who stops studying the moment the teacher says "Time's up," even if they haven't finished the exam, just because their internal clock said they were done.

The Cause: Too Much Trust in the "Plan"

The authors found that these robots suffer from Modality Imbalance. They are like a driver who is so focused on the GPS instructions ("Turn left in 500 feet") that they ignore the fact that there is a giant wall blocking the road. The robot trusts its internal state (the GPS) too much and ignores the visual evidence (the wall).

The Solution: ReViP (The "Reality Check" System)

The paper proposes a new system called ReViP (Vision-Proprioception Rebalance). Think of ReViP as adding a smart co-pilot or a critical observer to the robot's brain.

Here is how it works, using a simple analogy:

1. The Task-Stage Observer (The "Reality Check"):
   Imagine a second, super-smart robot (powered by a large AI) that isn't doing the moving. Its only job is to watch the scene and the instructions. It constantly asks: "Wait, did the cheese actually fall? Is the robot actually holding it? What stage of the task are we really at?"

   • If the cheese falls, this observer immediately shouts, "Alert! The cheese is on the floor! The plan is broken!"

2. The Task-Stage Enhancer (The "Volume Knob"):
   This is the part that talks to the main robot brain. When the "Reality Check" shouts an alert, the Enhancer turns up the volume on the robot's eyes and turns down the volume on its muscle memory.

   • Instead of blindly following the old plan, the robot is forced to look at the floor, see the cheese, and say, "Okay, new plan: Go pick up the cheese."

The Results: A Smarter Robot

The researchers tested this on a new "exam" they created called the False-Completion Benchmark. They set up traps like:

• Object Drop: Making the robot drop the item mid-task.
• Distractor Swap: Swapping the target object with a fake one that looks similar.
• Relayout: Moving the table and objects to new spots.

The outcome?

• Old Robots: Kept walking toward the plate with empty hands, declaring victory while failing.
• ReViP Robot: Saw the item fall, stopped, went back to pick it up, and actually finished the job.

In simple terms, ReViP taught the robot to stop being stubborn about its internal plan and start listening to its eyes. It balanced the robot's "muscle memory" with its "sight," resulting in a robot that is much less likely to lie to you about whether it actually finished the job.

The Bottom Line:
ReViP fixes the robot's "denial" by giving it a second opinion that forces it to pay attention to reality, ensuring that when it says "I'm done," it actually means it.

Technical Summary

Here is a detailed technical summary of the paper "ReViP: Mitigating False Completion in Vision-Language-Action Models with Vision-Proprioception Rebalance."

1. Problem Definition: False Completion

The paper identifies a critical failure mode in Vision-Language-Action (VLA) models termed "False Completion."

• Definition: A scenario where a robot policy prematurely declares task success or halts execution despite the visual evidence showing that the goal has not been met (e.g., an object has dropped, but the robot continues to the goal location and stops).
• Root Cause: The authors attribute this to Modality Imbalance, specifically a State-Dominant Bias. Current VLA models tend to over-rely on internal proprioceptive signals (joint states, gripper status) and underutilize external visual feedback. When a visual failure occurs (like an object drop), the policy ignores the visual cue and blindly follows the internal state trajectory, leading to incorrect task termination.
• Limitation of Naive Solutions: Simply removing proprioceptive inputs forces the model to rely on vision but drastically reduces overall task success rates because proprioception provides critical information for stable control. The challenge is to rebalance these modalities rather than discard one.

2. Methodology: ReViP Framework

To address this, the authors propose ReViP (Rebalancing Vision-Proprioception), a framework designed to enhance visual grounding and adaptively modulate the coupling between semantic perception and proprioceptive dynamics.

Core Components:

1. Task-Stage Observer (TSO):

   • Function: An external Vision-Language Model (VLM), specifically using Qwen2.5-VL, acts as an observer.
   • Input: It processes the current observation ($I_t$) and the language instruction ($l$).
   • Output: It performs task-relevant reasoning to extract progress-aware visual cues. It identifies the physical state of objects, their spatial locations, and summarizes the immediate task stage intention (e.g., "The cream cheese is not grasped; locate it on the floor").
   • Mechanism: The TSO converts these discrete language cues into a compact continuous feature vector ($z_t$) via embedding extraction.

2. Task-Stage Enhancer (TSE):

   • Function: This module injects the progress-aware cues ($z_t$) into the main VLA backbone to rebalance the visual and proprioceptive streams.
   • Mechanism (TS-FiLM): It uses a Task-Stage Feature-wise Linear Modulation (TS-FiLM). The cues are mapped to modulation parameters ($\gamma_t, \beta_t$) via a lightweight bottleneck network.
   • Operation: These parameters modulate the vision-language prefix tokens ($P_t$) before action generation:
     $$\tilde{P}_t = (P_t + \alpha (\gamma_t \odot P_t + \beta_t)) \odot M_t$$
   • Effect: This operation adaptively amplifies feature channels aligned with visual evidence (e.g., a dropped object) and attenuates those driven by state bias, effectively steering the policy to replan (e.g., re-grasp) rather than proceed blindly.

3. Action Prediction:

   • The modulated representation is fed into a flow-matching-based action generator to predict action chunks, conditioned on the rebalanced features.

3. Key Contributions

1. Identification of False Completion: The paper formally defines "False Completion" as a distinct failure mode caused by modality imbalance and systematically analyzes it through modality-controlled experiments (showing that state-masking improves recovery but hurts general performance).
2. False-Completion Benchmark Suite: The authors introduce the first benchmark suite specifically designed to evaluate false completion. It features:
   • 8 Distinct Tasks based on the LIBERO benchmark.
   • 3 Controlled Perturbations:
     • Object Drop: Tests recovery from unexpected displacement.
     • Distractor Swap: Tests instance-level grounding when targets and distractors swap places.
     • Relayout: Tests adaptability to changes in spatial configuration.
3. ReViP Framework: A novel architecture that integrates an external VLM observer with a feature-level modulator to rebalance vision and proprioception without discarding proprioceptive data.
4. Extensive Validation: Comprehensive evaluation across simulation (LIBERO, RoboTwin 2.0) and real-world robotic platforms.

4. Experimental Results

The paper demonstrates that ReViP significantly outperforms state-of-the-art (SOTA) baselines (including $\pi_0$, $\pi_0$-Fast, OpenVLA, and UniVLA).

• False-Completion Benchmark:

  • ReViP achieved an average success rate of 59%, outperforming the strong baseline $\pi_0$ (36%) by 23% and $\pi_0$-Fast (44%) by 15%.
  • The enhanced version, ReViP* (using a larger 72B VLM observer), achieved 62% success, a 26% gain over $\pi_0$.
  • Specific Gains:
    • Object Drop: Improved from 24% ($\pi_0$) to 62.4% (ReViP).
    • Distractor Swap: Improved from 6% to 26%.
    • Relayout: Improved from 70% to 84%.

• General Simulation Benchmarks:

  • LIBERO: ReViP achieved a 96.7% average success rate across all suites, surpassing $\pi_0$ (94.2%) and UniVLA (95.2%). It saturated the LIBERO-Spatial suite at 99.0%.
  • RoboTwin 2.0 (Dual-Arm): ReViP achieved a 21% average success rate on hard-mode dual-arm tasks, significantly outperforming $\pi_0$ (10%) and RDT (6%).

• Real-World Experiments:

  • Tested on a ROKAE 6-DoF arm with JODELL gripper.
  • ReViP achieved 88% success rate on standard tasks with perturbations, compared to 62% for $\pi_0$.
  • In extended challenging settings (high-contrast backgrounds, small objects), ReViP maintained 73% success vs. 34% for $\pi_0$.

• Efficiency: ReViP introduces only modest latency (62.4ms vs. 44.6ms for $\pi_0$) and maintains a control frequency of 16 Hz, sufficient for real-time operation.

5. Significance

• Paradigm Shift: The paper moves beyond the "remove state to fix bias" approach, proposing a rebalancing strategy that preserves the benefits of proprioception while correcting state-dominant errors.
• Robustness: It demonstrates that injecting high-level semantic reasoning (via TSO) into low-level control policies significantly improves robustness against dynamic disturbances, a critical requirement for real-world deployment.
• Community Resource: The release of the False-Completion Benchmark Suite provides a standardized metric for the community to evaluate and improve VLA robustness against a specific, previously under-explored failure mode.
• Plug-and-Play: The framework is shown to be architecture-agnostic, successfully improving performance when applied to different VLA backbones ($\pi_0$ and $\pi_0.5$).

In conclusion, ReViP effectively mitigates the "blind persistence" of current VLA models by dynamically rebalancing visual and proprioceptive signals, leading to more human-like, common-sense task completion in the face of errors.