Tracing Causal Dependencies to Diagnose Plan Failures

118 concepts80 papers1 proposal

When an autonomous agent or planning system makes a mistake, the traditional response in early AI architectures was simple chronological backtracking: undo the last action, try an alternative, and repeat until something works. However, as highlighted by Xinrun Xu et al. in DeepPHY: Benchmarking Agentic VLMs on Physical Reasoning, this blind trial-and-error often leads to myopic planning, where agents repeatedly execute the same failed actions without understanding why they are failing.

To build truly robust agents, a system must perform causal failure attribution. Instead of treating a failure as an isolated event, the system must trace the error back to the specific underlying assumptions, environmental constraints, or broken prerequisites that caused it. By leveraging explicit justification structures, systems can diagnose failures, perform surgical plan repairs, and extract generalized knowledge from a single mistake.

Explicit Justification Structures

To diagnose why a plan failed, a system cannot rely solely on execution traces that show which rules fired. It needs a formal representation of why those choices were made in the first place.

Reid G. Smith et al. established this foundational concept in Representation and Use of Explicit Justifications for Knowledge Base Refinements, arguing that tracing failures back to foundational beliefs requires explicit justifications for every system state. Similarly, Subbarao Kambhampati introduced "validation structures" in A Theory of Plan Modification to map the internal dependencies and justifications for each step in a plan. Without these causal links, a system cannot identify which specific actions are disrupted by environmental changes, forcing it to discard potentially useful plan segments entirely.

By structuring knowledge as an acyclic dependency graph, as proposed by Reid G. Simmons in A Theory of Debugging Plans and Interpretations, an agent can traverse from a failed outcome back to its leaf assumptions. This turns credit assignment from a guessing game into a precise structural traversal: every internal expectation is linked directly to the decision-making components and rules that generated it, a mechanism formalized by Bruce Krulwich et al. in Determining What to Learn Through Component-Task Modeling.

[ Foundational Assumption ] ---> [ Plan Step / Action ] ---> [ Internal Expectation ]
                                                                     |
                                                                     v
[ Isolated Root Cause ] <------- [ Backward Traversal ] <------- [ Plan Failure ]

Backward Causal Tracing and Backjumping

Once a failure occurs, how does the system isolate the root cause? The core mechanism is backward causal tracing or causal back-chaining.

In his seminal work on case-based planning, Kristian J. Hammond demonstrated in Learning to Anticipate and Avoid Planning Problems through the Explanation of Failures how tracing the chain of events from a failed goal back to initial conditions allows a planner to understand structural conflicts. Instead of blindly undoing the immediate precursor to a failure, the system regresses the impasse to its true historical origin.

This concept drastically improves search efficiency. Subbarao Kambhampati demonstrated in Improving Graphplan's Search with EBL & DDB Techniques that propagating failure explanations backward through a reachability structure allows planners to identify conflict sets far in advance. In long-horizon tasks, this enables "backjumping"—skipping over irrelevant intermediate actions to directly modify the culprit transition, a technique modernized by Yoonchang Sung et al. in Learning to Correct Mistakes: Backjumping in Long-Horizon Task and Motion Planning.

Counterfactual Reasoning and Disambiguation

Attributing a failure often requires evaluating what would have happened if conditions were different. This involves counterfactual reasoning and the systematic retraction of assumptions.

Wayne Wobcke in A Schema-Based Approach to Understanding Subjunctive Conditionals grounded counterfactuals by treating actions as necessary components within a sufficient set of causal conditions, allowing agents to simulate broken causal chains by removing components from a known chain. When a system operates under simplified models, Randall Davis et al. in Diagnosis Based on Description of Structure and Function showed that the system can systematically retract simplifying assumptions to explore more complex failure hypotheses when standard reasoning fails.

Furthermore, when a plan fails in a complex environment, it can be ambiguous whether the failure stems from an invalid action choice or a missing prerequisite in the dependency chain. As Seungjoon Lee et al. showed in Experience-based Knowledge Correction for Robust Planning in Minecraft, a failure disambiguation mechanism can systematically test all available actions to isolate whether the execution or the underlying dependency graph is flawed, allowing the agent to precisely target the source of planning errors.

Modern Applications in Code Optimization and Robotics

The principles of explicit justification and causal tracing remain highly relevant in modern neuro-symbolic and generative AI systems.

For instance, Zhiyi Kuang 0003 et al. in Learning Game-Playing Agents with Generative Code Optimization utilize backtracing through execution graphs to allow Large Language Models to identify specific points of failure in an agent's logic and infer environment physics.

In robotics, Sertac Karapinar et al. in Failure Handling In a Planning Framework integrate probabilistic reasoning with temporal planning to prevent robots from executing irrelevant recovery actions, ensuring that subsequent maneuvers are logically linked to the diagnosed cause of the failure. Finally, frameworks like JEDAI by Trevor Angle et al. in JEDAI Explains Decision-Making AI translate these formal unmet preconditions into human-readable explanations, allowing non-experts to debug autonomous behaviors effectively without needing to understand underlying formal planning languages.

History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_justification_structures_7c289dcb,
  title = {justification structures},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/justification-structures/rdr_7c289dcb6a5d4a65bacdea49fecdd0e3},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-19},
}

This exact version (version 1, frozen text):

@misc{lacuna_justification_structures_7c289dcb_v1,
  title = {justification structures},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/justification-structures/rdr_7c289dcb6a5d4a65bacdea49fecdd0e3/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-19},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake