A Hierarchical Error-Corrective Graph Framework for Autonomous Agents with LLM-Based Action Generation

This paper proposes the Hierarchical Error-Corrective Graph Framework (HECG) for autonomous agents, which integrates Multi-Dimensional Transferable Strategy (MDTS) for precise candidate selection, Error Matrix Classification (EMC) for structured failure attribution, and Causal-Context Graph Retrieval (CCGR) for enhanced contextual reasoning to improve execution reliability in complex, multi-step tasks.

The Gist

Imagine you are teaching a very smart, but slightly clumsy, robot butler to clean your house. You give it a big instruction: "Make breakfast, wash the dishes, and then tidy the living room."

In the past, if you asked a robot to do this, it would try to follow your instructions like a rigid script. If it tried to pick up a coffee mug and missed because the mug was slightly hidden, the robot would either crash, get stuck, or just give up and say, "I failed." It didn't know how to fix the mistake, only that it made one.

This paper introduces a new system called HECG (Hierarchical Error-Corrective Graph). Think of it as giving the robot a smart, self-correcting GPS and a team of expert coaches instead of just a single script.

Here is how it works, broken down into three simple ideas:

1. The "Smart Map" (The Graph)

Instead of a straight line of instructions (Step A → Step B → Step C), the robot's plan is a choose-your-own-adventure book or a complex subway map.

• The Nodes: Every step (like "pick up mug") is a stop on the map.
• The Paths: From every stop, there isn't just one path forward. There are:
  • The Main Path: The normal way to do it.
  • The Detour Path: If the main path is blocked, take this alternative route.
  • The Repair Path: If you drop the mug, this path tells you how to pick it up again without restarting the whole day.
  • The "Call for Help" Path: If the robot is totally stuck, it knows when to ask a human for help.

This map allows the robot to navigate around problems instantly instead of crashing.

2. The "Three-Level Coach" (Hierarchical Correction)

When the robot makes a mistake, it doesn't just panic. It has a three-level team of coaches that step in, starting with the least expensive fix and only calling in the big guns if necessary.

• Level 1: The "Nudge" Coach (Local Correction)
  • Scenario: The robot tries to grab a cup but misses by an inch.
  • Fix: The coach says, "Just move your hand two centimeters to the left and try again." No big deal!
• Level 2: The "Strategy" Coach (Switching Actions)
  • Scenario: The robot tries to grab the cup, but it's too heavy or slippery.
  • Fix: The coach says, "Grabbing isn't working. Let's try pushing the cup to the edge of the table instead." The goal is the same, but the method changes.
• Level 3: The "General" Coach (Re-planning)
  • Scenario: The robot keeps failing, or the kitchen is a mess.
  • Fix: The coach says, "Forget the current plan. Let's throw it out and write a brand new one that avoids the mess we just made."

3. The "Super-Intelligent Librarian" (Causal-Context Graph)

This is the brain behind the scenes. Usually, when a robot fails, it forgets the details of why it failed. It just remembers "I failed."

This new system acts like a Librarian who remembers every story ever told.

• It doesn't just look for words that sound similar (like "cup" and "mug").
• It looks at the story structure: "Last time, the robot tried to grab a cup while the light was off, and it failed. It succeeded when it turned the light on first."
• When the robot faces a new problem, the Librarian pulls up the exact "story" of a similar past success and says, "Hey, remember that time you turned on the light? Do that again."

Why is this a big deal?

Imagine driving a car.

• Old Way: If you hit a pothole, the car stops, the engine turns off, and you have to call a tow truck (the robot crashes and needs a human to restart it).
• New Way (HECG): If you hit a pothole, the car's suspension absorbs it (Level 1). If the road is blocked, the GPS instantly reroutes you (Level 2). If the whole road is gone, the GPS finds a completely new highway to your destination (Level 3).

In short: This paper teaches robots how to think on their feet. It combines the creativity of a human (using a Large Language Model to understand context) with the discipline of a machine (using a structured map to track errors), creating an agent that is much harder to break and much better at finishing its chores.

Technical Summary

1. Problem Statement

Autonomous agents, particularly those utilizing Large Language Models (LLMs) for planning, face significant challenges when executing complex, long-horizon tasks in dynamic and partially observable environments. The paper identifies three critical limitations in current approaches:

• Inadequate Strategy Transferability: Traditional methods rely on single-dimensional metrics (e.g., cumulative reward) or simple weighted scoring, failing to capture the semantic compatibility and contextual alignment required for transferring strategies between different tasks.
• Lack of Structured Error Attribution: Existing feedback mechanisms often provide only binary success/failure signals. They lack a structured mechanism to categorize the type, source, and severity of failures, preventing systematic root-cause analysis and targeted correction.
• Superficial Retrieval in RAG: Current Retrieval-Augmented Generation (RAG) methods rely heavily on vector similarity or token matching. This captures only superficial semantic proximity, ignoring the causal, temporal, and structural dependencies embedded in historical state-action trajectories, which limits the agent's ability to leverage structured experience for adaptation.

2. Methodology: The HECG Framework

The authors propose the Hierarchical Error-Corrective Graph (HECG) framework. This framework integrates LLM-based action generation with a structured, graph-based control system that enables adaptive execution and multi-level error correction.

A. Graph-Based Task Representation

The LLM-generated plan is not treated as a rigid sequence but as a directed graph $G=(V, E)$:

• Nodes ($V$): Represent executable actions or subgoals. Each node encapsulates the action content, expected outcome, local error thresholds, and specific correction rules.
• Edges ($E$): Represent transitions conditioned on execution outcomes. Edge types include:
  • Main: Nominal task flow.
  • Optional: Alternative actions for the same subgoal (redundancy).
  • Correction: Triggered by local errors exceeding a threshold but remaining recoverable.
  • Fallback: Triggered by severe errors, leading to higher-level replanning or human intervention.

B. Core Innovations

The framework introduces three core mechanisms to address the identified problems:

1. Multi-Dimensional Transferable Strategy (MDTS):

   • Instead of single metrics, MDTS evaluates candidate strategies using a composite score combining:
     • Q (Quality): Task value/progress.
     • C (Cost): Execution cost (time, energy).
     • R (Risk): Estimated failure likelihood.
     • LLM-Score: Semantic feasibility and commonsense reasoning derived from the LLM.
   • This allows for precise selection of high-quality strategies and reduces negative transfer by aligning quantitative performance with semantic context.

2. Error Matrix Classification (EMC):

   • Replaces binary success/failure with a structured taxonomy of 10 error types (e.g., Strategy Errors, Script Parsing Errors, Sensor Failures, Collision Detection).
   • Errors are categorized by severity (recoverable vs. unrecoverable) and mapped to a three-level correction hierarchy:
     • Level 1 (Local Correction): Fine-grained parameter adjustments (e.g., re-grasping).
     • Level 2 (Optional Action Switching): Switching to an alternative strategy (e.g., pushing instead of grasping).
     • Level 3 (Task Re-Planning): Regenerating the entire plan with constraints derived from failure history.
     • Level 4 (Human-in-the-Loop): Escalation for critical failures.

3. Causal-Context Graph Retrieval (CCGR):

   • Constructs a memory graph from historical states, actions, and events where edges represent causal dependencies.
   • Retrieval is performed via subgraph matching rather than flat vector similarity. This allows the agent to retrieve structurally aligned execution patterns and causal chains, significantly improving context awareness and strategy adaptation in complex tasks.

C. Transition Policy

The agent selects transitions using a probabilistic policy that integrates the MDTS components:
$$\pi_{ij}^k = \text{Softmax}(\alpha Q_{ij}^k - \beta C_{ij} - \gamma R_{ij} + \lambda \Phi_{LLM})$$
Transitions are triggered based on real-time error metrics ($e_i$) against thresholds ($\epsilon_i, \epsilon_{max}$), creating a hybrid switching system that adapts dynamically to execution feedback.

3. Key Contributions

• Structured Error Handling: The introduction of the Error Matrix Classification (EMC) provides a systematic way to diagnose and recover from diverse failure modes, moving beyond simple success rates.
• Graph-Based Execution: Transforming linear LLM plans into a hierarchical graph with explicit correction and fallback paths enables robust, adaptive execution without requiring full global replanning for minor errors.
• Multi-Dimensional Strategy Evaluation: The MDTS framework bridges the gap between quantitative RL metrics and qualitative LLM reasoning, enabling better strategy selection and transfer.
• Causal Retrieval: CCGR leverages graph structures to retrieve experiences based on causal relationships rather than just semantic similarity, enhancing long-horizon planning reliability.

4. Experimental Results

The framework was evaluated in the VirtualHome environment across diverse household tasks (e.g., ReadBook, PrepareFood, PutFridge) using models like GPT-5 Mini, DeepSeek-R1, and LLaMA3.3-70B.

• Performance Improvement: Models equipped with HECG (specifically the "HECG Full" variant) demonstrated significantly higher Task Success Rates (TSR) after replanning and correction compared to flat LLM planners.
• Correction Efficacy: The Corrective Success Rate (TSR_C) for GPT-5 Mini reached 1.0 in many tasks, indicating that when errors occurred, the hierarchical correction mechanism successfully recovered the task.
• Ablation Studies:
  • Risk Term ($R$): Removing the risk term caused the largest performance drop, leading to frequent execution failures.
  • LLM Score ($\Phi_{LLM}$): Removing LLM guidance resulted in semantically implausible transitions (e.g., clearing a table before picking up an object) and increased recovery steps.
  • Value & Cost Terms: These were crucial for long-horizon planning efficiency and minimizing unnecessary recovery actions.
• Robustness: The full policy showed high stability across varying error thresholds, whereas ablated variants (especially those without Risk or LLM scores) were highly sensitive to threshold tuning.

5. Significance

This work represents a significant step forward in Embodied AI by addressing the "plan-environment alignment gap."

• Reliability: It transforms brittle, open-loop LLM plans into robust, feedback-driven control processes capable of handling real-world uncertainties (noise, occlusion, dynamic obstacles).
• Interpretability: The graph structure and error matrix provide transparent reasoning for why specific corrections or replans were triggered, making agent behavior more explainable.
• Scalability: By enabling local corrections and optional switching, the framework reduces the computational cost of frequent global replanning, making it more scalable for long-horizon tasks.
• Future Impact: The framework offers a systematic blueprint for integrating LLMs with structured error handling, paving the way for more reliable autonomous robots in complex, unstructured environments.