Technical Summary: Grounded Iterative Language Planning (GILP)

1. Problem Statement

The paper addresses the challenge of hallucination propagation in long-horizon planning tasks performed by Large Language Model (LLM) agents. In standard agent-based planning (e.g., ReAct, Chain-of-Thought), the LLM acts as both the planner and the agent-based world model. It generates an action and simultaneously predicts the next state (a "delta") in natural language or structured JSON.

The core issue is that errors in these state predictions are semantic hallucinations (e.g., claiming a task is completed when it is not, or ignoring a dependency). Unlike parameterized models, these errors are not easily quantifiable by standard regression losses (like MSE). Once a hallucinated state atom enters the context window, it propagates through subsequent steps, causing a cascade of invalid actions and task failure. The paper notes that while agent-based models excel at semantic reasoning, their error rates compound significantly over long horizons (e.g., reaching a per-step error probability of 0.393 by step 10 in experiments).

Conversely, parameterized world models (trained transition predictors) offer measurable, supervised error metrics (NodeMSE, delta accuracy) but often lack the semantic flexibility to reason about complex, novel goals, resulting in lower standalone success rates.

2. Methodology: Grounded Iterative Language Planning (GILP)

GILP is a hybrid architecture designed to combine the semantic reasoning of API-based LLM agents with the measurable transition signals of a small, trained parameterized backbone. The system operates in an iterative loop with four distinct phases:

Phase 1: Parameterized Skeleton Scoring

A small, trained neural network (the "backbone," typically a Graph Neural Network or MLP) receives the current state $G_t$ and candidate actions $A_t$. It predicts:

• Action validity ($p_{valid}$)
• State deltas ($\hat{\Delta}G$)
• Risk ($\hat{\rho}$)
• Value ($\hat{U}$)
• Completion probability ($\hat{p}_{done}$)

The backbone compresses the candidate action set into a "skeleton" (top-$k$ actions by value and risk) to reduce context window overhead.

Phase 2: LLM Draft

The LLM agent receives the serialized state, the goal, and the skeleton from Phase 1. It drafts an action and an imagined next-state delta ($\tilde{\Delta}_t$) in structured JSON. This phase leverages the LLM's reasoning capabilities.

Phase 3: Consistency Gate and Corrective Re-prompting

This is the core mechanism for hallucination reduction. The system compares the LLM's imagined delta ($\tilde{\Delta}_t$) with the backbone's predicted delta ($\hat{\Delta}G$) using Jaccard similarity on the set of changed nodes.

• High Consistency ($\ge 0.70$): The action is accepted.
• Medium Consistency ($0.30 \le cons < 0.70$): The action is accepted but penalized in ranking.
• Low Consistency ($< 0.30$): A corrective re-prompt is triggered. The system sends a targeted message to the LLM explicitly listing the nodes where the backbone and LLM disagree (e.g., "Node X: backbone predicts pending, you imagined completed"). The LLM is asked to revise its action or state delta. This correction is capped at one revision per step to bound costs.

Phase 4: Risk Gate

If the backbone's predicted risk for the chosen action exceeds a threshold ($\rho_{th} = 0.65$), a third LLM call is triggered to warn the agent and restrict the action space to low-risk options, preventing catastrophic failures (e.g., retrying a task with an unresolved root cause).

3. Key Contributions

1. Comparative Framework: The paper frames long-horizon planning as a trade-off between two world model families: flexible but hallucination-prone agent-based models, and measurable but semantically weaker parameterized models.
2. Operational Hallucination Metrics: It defines specific metrics for agent-based errors that go beyond standard loss functions:
   • Hallucinated-State Rate (HSR): The fraction of imagined state atoms that disagree with ground truth.
   • Propagation Depth (PD): The mean number of subsequent steps conditioned on a hallucinated atom.
   • Error-Explosion Slope (EES): The rate at which errors compound over time.
3. GILP Architecture: The introduction of a hybrid system that uses a small, trained backbone not to solve the task, but to provide a "grounding signal" (validity, delta, risk) to correct the LLM's state predictions via a consistency gate.
4. Empirical Validation: Extensive evaluation across four graph-structured benchmarks (TaskGraph, ToolChain, ResourceAlloc, RepairFlow) and real-world API calls (GPT-4o-mini).

4. Experimental Results

The results are derived from a calibrated behavioral simulator (validated against real GPT-4o-mini runs) and direct API testing.

• Success Rate (SR): GILP achieves a success rate of 0.838 on pooled benchmarks, significantly outperforming the best agent-only baseline (Agent-Replan at 0.668) and parameterized-only planners (0.565–0.625).
• Hallucination Reduction:
  • Simulator: HSR drops from 0.205 (Agent-Replan) to 0.079 (GILP).
  • Real API (GPT-4o-mini): HSR drops from 0.176 to 0.035 (an 80% relative reduction).
• Long-Horizon Performance: For tasks with horizons $H > 10$, the agent-only success rate collapses to 0.471, whereas GILP maintains 0.758.
• Cost Efficiency: GILP adds approximately 22% extra LLM calls per step (due to occasional correction and risk gates) but reduces the total tokens required per solved task compared to uncorrected agents because it solves more episodes.
• Backbone Strength: The parameterized backbone does not need to be a strong planner. Even a weak MLP (standalone SR 0.509) significantly improves the hybrid system (SR 0.768) when used as a grounding signal.
• Multi-API Robustness: GILP equalizes performance across different LLM APIs (GPT-4o-mini, Claude-3-Haiku, Gemini-1.5-Flash, Llama-3-8B), reducing the HSR variance and making open-source models competitive with proprietary ones when grounded.

5. Significance and Claims

The paper claims that the primary contribution is not the superiority of the parameterized model, but the division of labor it enables. The agent retains its semantic reasoning and flexibility, while the parameterized backbone provides a "cheap, measurable, and auditable" signal to detect and correct state hallucinations before they propagate.

The authors emphasize that:

• Hallucination is a propagation problem: A single false token can invalidate an entire trajectory; GILP interrupts this cascade.
• Small training suffices: A small, trained backbone is sufficient to ground an API-based agent; it does not need to replace the agent's reasoning capabilities.
• Targeted correction is efficient: The consistency gate only triggers re-prompts when necessary (approx. 22% of steps), avoiding the high cost of verifying every step with a large model.

The paper concludes that GILP offers a practical path to reducing hallucination in autonomous agents without sacrificing the reasoning capabilities of large language models, achieving high success rates with only a marginal increase in computational cost.