Causal Attribution for Plan Debugging and Recovery

This direction is merged into another direction: justification structures. Its last version stays readable and citable here.

Version 1 of 128 papers35 conceptsfrozen 2026-10-04

When an autonomous agent fails—whether it’s a robot missing a grasp or a software planner hitting a logical dead end—the most common response is to backtrack or restart. However, a binary "success or failure" signal provides no information on how to fix the underlying problem. To move beyond blind trial-and-error, research across four decades has converged on a shared principle: Causal Failure Attribution. Instead of treating a bug as an isolated event, these systems treat it as a symptom of a specific, traceable contradiction in their internal model of the world.

From Surface Symptoms to Root Causes

The fundamental challenge in debugging a complex system is the gap between where an error is observed and where it actually originated. In early expert systems, Reid G. Smith, Howard A. Winston, Tom M. Mitchell, and Bruce G. Buchanan argued that standard execution traces are insufficient because they only show which rules fired, not why those rules were believed to be valid in the first place. Their work in Representation and Use of Explicit Justifications for Knowledge Base Refinements proposed that systems must maintain "justifications"—explicit records of the assumptions and approximations underlying every decision.

This intuition was formalized by Reid G. Simmons in A Theory of Debugging Plans and Interpretations. Simmons viewed a plan as an acyclic dependency graph. When a predicted outcome fails to materialize, the system "back-chains" through this graph, traversing from the failed goal to the foundational assumptions at the leaves. By isolating which specific premise—such as a physical constant or a rule about gravity—was violated, the agent can perform a targeted repair rather than discarding the entire plan.

The Power of Pedagogical Feedback

In modern contexts, such as Large Language Model (LLM) planning, the need for causal clarity is even more acute. LLMs often "hallucinate" plans that look plausible but violate physical constraints. In Grounding Generative Planners in Verifiable Logic, Feiyu Wu and colleagues introduce a "Tutor" that provides pedagogical diagnostic reports. Instead of telling the LLM "this plan failed," the Tutor explains the causal mechanism: "You cannot heat the soup because the container is flammable." This causal explanation prevents the "reasoning dead ends" common in simple iterative refinement.

Similarly, the SDA-PLANNER framework by Tianchen Zhu and others uses a State-Dependency Graph to distinguish between environmental surprises and unmet preconditions. By pinpointing the "minimal invalid subsequence," the agent can backtrack to the exact logical origin of the failure, preserving the parts of the plan that still work.

Learning from a Single Mistake

One of the most powerful applications of causal attribution is Explanation-Based Learning (EBL). While traditional machine learning requires thousands of examples to recognize a pattern, causal systems can learn a general rule from a single failure.

Kristian J. Hammond demonstrated this with CHEF, a case-based planner that creates recipes. When a recipe fails (e.g., the strawberries turn to mush), CHEF doesn't just mark that recipe as "bad." It uses a causal model to explain why the failure happened (the interaction between high heat and fruit moisture). This explanation is then generalized into a "failure predictor" that allows the system to avoid similar mistakes in entirely different contexts, such as cooking with other delicate ingredients.

This concept of "Learning From Failures" (LFF) remains relevant in symbolic AI today. Rolf Morel showed in Constraint-Driven Learning of Logic Programs that identifying the specific sub-programs responsible for an error allows a system to prune massive sections of the search space, making the discovery of complex recursive programs computationally feasible.

Counterfactual Reasoning and Attribution

The most recent frontier in this area involves using causal inference to handle multi-agent or high-dimensional environments where the "root cause" is obscured by noise. Alva West and Andrew A. West introduced the Abduct-Act-Predict (A2P) framework to solve this.

A2P forces models to move beyond pattern recognition and engage in counterfactual reasoning: "If Agent A had not made that specific comment, would the conversation still have failed?" By simulating these "what-if" scenarios, the system can distinguish between incidental anomalies and the decisive errors that actually caused the collapse. This same logic is applied to embodied AI in RoboBench, where Cheng Chi and colleagues evaluate whether models can perform causal reasoning on visual feedback to recover from physical execution errors.

Summary of the Intuition

Causal failure attribution works because it transforms a search problem into a reasoning problem.

  1. Trace: Use dependency graphs or justification structures to link the failure back to its logical ancestors (Collins et al.).
  2. Explain: Generate a causal proof or pedagogical report that identifies the specific contradiction (Simmons & Davis, Wu et al.).
  3. Generalize: Convert that specific explanation into a general constraint to avoid an entire class of future errors (Hammond, Morel).

By understanding the "why" of a failure, agents stop being fragile executors of scripts and start becoming resilient problem-solvers.

Papers in this version

History & citationVersion 1 · 2026-10-04

Merged into another direction · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_causal_attribution_for_plan_debugging_an_eb265fb7,
  title = {Causal Attribution for Plan Debugging and Recovery},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/causal-attribution-for-plan-debugging-and-recovery/rdr_eb265fb7efbb472e9c83a2560d747b51},
  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_causal_attribution_for_plan_debugging_an_eb265fb7_v1,
  title = {Causal Attribution for Plan Debugging and Recovery},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/causal-attribution-for-plan-debugging-and-recovery/rdr_eb265fb7efbb472e9c83a2560d747b51/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-19},
}