💻 computer science

Where Did It Go Wrong? Capability-Oriented Failure Attribution for Vision-and-Language Navigation Agents

This paper proposes a capability-oriented testing framework that combines adaptive test case generation, capability-specific oracles, and feedback-driven attribution to effectively detect and pinpoint the root causes of failures in Vision-and-Language Navigation agents, outperforming existing system-level methods in both failure discovery and interpretability.

Original authors: Jianming Chen, Yawen Wang, Junjie Wang, Xiaofei Xie, Shoubin Li, Qing Wang, Fanjiang Xu

Published 2026-04-29

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Jianming Chen, Yawen Wang, Junjie Wang, Xiaofei Xie, Shoubin Li, Qing Wang, Fanjiang Xu

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 built a very smart robot butler designed to navigate your house based on spoken instructions like, "Go to the bedroom, pick up the blue towel, and put it on the bed."

Sometimes, this robot fails. It might walk into the wrong room, forget where it came from, or drop the towel in the hallway.

The Problem: The "Black Box" Mystery
Traditionally, when a robot fails, developers only know that it failed. They see the robot didn't reach the bed, but they don't know why. Was it because the robot couldn't see the towel (Perception)? Did it forget it was holding the towel (Memory)? Did it plan a path that was too long (Planning)? Or did it just decide to turn left instead of right (Decision)?

Because these skills are all tangled together, a mistake in one area often causes a chain reaction of errors in the others. It's like trying to fix a car that won't start, but you only know the engine is silent—you don't know if it's the battery, the fuel, or the spark plugs.

The Solution: CanTest (The "Skill-Specific Detective")
The paper introduces a new testing tool called CanTest. Instead of just watching the robot fail, CanTest acts like a specialized detective that breaks the robot's brain down into four distinct skills and checks each one individually.

Here is how CanTest works, using a simple analogy:

1. The "Stress-Test" Generator (Adaptive Test Case Generation)

Imagine you are trying to find the weak spots in a new bridge. You wouldn't just drive a car over it once; you would send heavy trucks, bouncy buses, and wind machines to see what breaks.

What CanTest does: It automatically creates thousands of navigation instructions. If the robot fails at a specific task (like finding a towel in a bathroom), CanTest gets "smart." It slightly changes the instructions (e.g., "Find the red towel" instead of the blue one) to see if the robot still fails. If the robot keeps failing, CanTest knows it has found a real weakness and tries to make the test even harder to expose the flaw.

2. The "Skill Checkers" (Capability Oracles)

This is the most important part. CanTest doesn't just watch the robot; it has four invisible "referees" watching the robot's brain in real-time.

The Perception Referee: Checks if the robot correctly "sees" objects. Did it actually spot the towel, or did it think a chair was a towel?
The Memory Referee: Checks the robot's mental notebook. Did it remember it came from the kitchen?
The Planning Referee: Checks the robot's map. Did it draw a path that actually leads to the bedroom?
The Decision Referee: Checks the robot's foot. Did it actually take the step it planned?

If the robot fails the task, these referees tell CanTest exactly which "referee" raised a red flag.

3. The "Root Cause" Finder (Failure Attribution)

Sometimes, the robot makes a mistake early on, but the final failure happens much later.

The Analogy: Imagine a robot trips over a rug (Perception error), stumbles, and then drops a vase (Decision error). The vase breaking is the "failure," but the real problem was tripping over the rug.
What CanTest does: It uses a "what-if" simulation. It asks, "If the robot had seen the rug correctly, would it still have dropped the vase?" If the answer is "No, it would have succeeded," then CanTest knows the Perception error was the true culprit, not the Decision error. It pinpoints the very first link in the chain that broke.

4. The "Feedback Loop"

Once CanTest finds a weakness, it gives the developers a score. It says, "Hey, this robot is really bad at remembering where it's been." This score tells the test generator to create more tests specifically about memory, ensuring the developers fix that specific skill before moving on.

The Results

The researchers tested this on three advanced robot navigation models.

More Failures Found: CanTest found significantly more failure cases (about 23% to 33% more) than previous testing methods.
Better Diagnosis: It didn't just say "The robot failed." It said, "The robot failed because it couldn't remember the hallway," or "It failed because it couldn't decide which way to turn."
High Accuracy: When the researchers used CanTest's "referees" to fix the robot's mistakes, they could successfully repair the robot's behavior in over 80% to 96% of the cases. This proves the "referees" were accurate and reliable.

In Summary
CanTest is like a mechanic who doesn't just listen to a car's engine sputter; they have a diagnostic tool that tells them exactly which spark plug is misfiring. By testing the robot's specific skills (seeing, remembering, planning, deciding) rather than just the final result, developers can fix the exact problem, making the robot safer and more reliable for real-world use.

1. Problem Statement

Context: Embodied agents, particularly in Vision-Language Navigation (VLN), rely on a complex chain of interdependent capabilities: Perception (interpreting visual inputs), Memory (recalling past states), Planning (generating routes), and Decision (executing actions).
The Challenge:

Error Propagation: Failures in one capability often cascade, causing subsequent errors in others. For example, a perception error (misidentifying a landmark) leads to flawed memory updates, bad planning, and incorrect decisions.
Black-Box Testing Limitations: Existing testing methods are largely system-level. They can detect if a task failed (e.g., the agent didn't reach the target) but cannot pinpoint which capability caused the failure or when it occurred.
Lack of Attribution: Without knowing the root cause (e.g., "the agent failed because it forgot the path" vs. "it failed because it couldn't see the door"), developers cannot effectively target improvements.
Goal: Develop an automated testing framework that not only discovers failure cases but also attributes them to specific capability deficiencies (Perception, Memory, Planning, or Decision) to provide actionable insights.

2. Methodology: CanTest

The authors propose CanTest, a capability-oriented testing framework consisting of three core modules:

A. Adaptive Test Case Generation

Instead of random testing, CanTest uses a feedback-driven search process to generate challenging navigation instructions.

Seed Corpus: Starts with a set of task instructions derived from 3D scene assets (rooms and objects).
Adaptive Selection: Seeds are selected based on a feedback score. Higher scores indicate a higher likelihood of exposing capability failures.
Mutation Strategies:
- Mild Mutation: Makes small semantic changes (e.g., changing the target object within the same room) to preserve failure-relevant patterns.
- Aggressive Mutation: Makes large changes (e.g., changing the destination room) to explore new search spaces and expose different weaknesses.
- The choice between mild and aggressive mutation is adaptive, based on the seed's feedback score.

B. Capability Oracles Construction

To evaluate capabilities independently, CanTest constructs Capability Oracles that define the "expected output" for each capability using expert models or ground truth data.

Perception Oracle: Uses an image annotation model (RAM) to generate expected object detections. It measures error via Weighted Intersection over Union (IoU) and semantic similarity between the agent's visual annotations and the ground truth.
Memory Oracle: Compares the agent's current memory description against the sequence of visual annotations from the ground-truth historical route. It uses semantic similarity (via LLM) to quantify recall accuracy.
Planning Oracle: Compares the agent's planned route against the ground-truth optimal path using Normalized Dynamic Time Warping (nDTW) to account for spatial and temporal alignment.
Decision Oracle: Directly compares the agent's executed action against the action planned by the upstream planning module.

C. Capability-Oriented Failure Attribution & Feedback

This is the core innovation for diagnosing why a failure occurred.

Counterfactual Reasoning: When a trajectory fails, CanTest identifies all capability errors detected by the oracles. It then performs counterfactual intervention: it replaces the erroneous capability output with the oracle's expected output and re-simulates the rest of the trajectory.
- If the trajectory becomes successful, the error is deemed failure-inducing.
- If multiple errors are failure-inducing, the earliest one is identified as the failure-source.
Feedback Score Calculation: The system computes a composite score for the next test generation cycle:
- $F_{cs} = F^f + \lambda_{Cx} F^c$
- $F^f$ : Binary failure signal (0 for success, 1 for failure).
- $F^c$ : Normalized error magnitude of the failure-source capability.
- $\lambda_{Cx}$ : An adaptive weight that balances exploration across different capabilities (reducing weight for capabilities that have already generated many failures to ensure diverse testing).

3. Key Contributions

First Capability-Oriented Testing Framework: The first work to propose automated test case generation specifically targeting individual capabilities of embodied agents, moving beyond system-level black-box testing.
Automated Capability Oracles: A novel mechanism to automatically construct oracles for Perception, Memory, Planning, and Decision, enabling independent evaluation of each module.
Failure Attribution Mechanism: A counterfactual reasoning approach that traces long-horizon task failures back to the specific capability and time step where the error originated.
Dual-Feedback Loop: A feedback mechanism that combines task-level failure signals with capability-level error magnitudes to guide the generation of highly targeted test cases.

4. Experimental Results

The framework was evaluated on three advanced VLN models (ApexNav, MGDM, Mem2Ego) in the Habitat3 simulation environment.

Failure Discovery: CanTest discovered significantly more failure cases than state-of-the-art baselines (Random, BehAVExplor, and VLATest). The improvement ranged from 23.34% to 33.70% over the best baseline.
Capability Attribution: CanTest identified the largest number of failures for each specific capability (Perception, Memory, Planning, Decision) compared to baselines augmented with CanTest's attribution modules.
Oracle Fidelity (Repair Rate): To validate the oracles, the authors "repaired" failure cases by replacing the agent's erroneous output with the oracle's expected output.
- Repair Rates: Achieved between 81.30% and 96.69% across all models and capabilities. This confirms that the oracles accurately identify the root cause of failures.
- Observation: Upstream capabilities (Perception, Memory) had slightly lower repair rates than Decision, indicating that errors in early stages are more complex and propagate further.
Ablation Study: Removing either the failure-oriented or capability-oriented feedback reduced performance, proving that both signals are essential for effective testing.

5. Significance and Impact

Actionable Debugging: Unlike traditional testing that only says "the agent failed," CanTest tells developers exactly which module failed (e.g., "The agent failed because its memory module forgot the path to the bedroom").
Targeted Improvement: By isolating specific capability deficiencies, developers can focus their efforts on improving specific modules (e.g., better object detection models or better memory integration) rather than retraining the entire agent.
Scalability: The framework is designed to handle the complexity of long-horizon tasks where errors compound over time, a critical challenge for real-world embodied AI.
Future Directions: The paper acknowledges limitations regarding the need for "expert models" (ground truth) and the challenge of transferring these oracles from simulation to the real world (Sim2Real), suggesting future work on human-in-the-loop supervision and learned surrogate oracles.

In summary, CanTest represents a paradigm shift in testing embodied agents, moving from "does it work?" to "why did it fail?" by providing a granular, capability-level diagnosis of navigation failures.