Localizing and Correcting Errors for LLM-based Planners

This paper proposes Localized In-Context Learning (L-ICL), a technique that iteratively augments instructions with targeted corrections for specific failing steps, significantly improving the ability of large language models to generate valid plans in symbolic classical planning tasks compared to traditional methods.

The Gist

Imagine you hire a brilliant but slightly clumsy architect to design a path through a maze. This architect (the Large Language Model, or LLM) is incredibly smart; they can write poetry, solve complex math problems, and understand human language better than anyone else. However, when it comes to following strict physical rules—like "you can't walk through walls" or "you can't push a box into a corner where it gets stuck"—they often make silly mistakes. They might suggest walking straight through a brick wall or pushing a box into a dead end, even though you told them not to.

This paper introduces a new way to teach this architect how to follow the rules, called L-ICL (Localized In-Context Learning).

The Problem: The "Whole Story" vs. The "Specific Mistake"

Traditionally, if you wanted to teach an AI how to navigate a maze, you would show it a few examples of perfect, complete solutions. You'd say, "Look, here is a person who started at the door and walked all the way to the treasure without hitting any walls."

The problem is that the AI gets overwhelmed. It sees the whole story but misses the tiny, specific rules that made the story work. It's like trying to learn how to drive a car by watching a 2-hour movie of a perfect road trip. You see the destination, but you don't learn exactly why the driver didn't hit that specific pothole or why they stopped at that specific red light. The AI tries to guess the rules, and it often guesses wrong, walking through walls or getting stuck.

The Solution: The "Spot-Check" Method (L-ICL)

The authors realized that instead of showing the AI the whole movie, they should just show it the exact moment it made a mistake and correct it immediately.

Think of it like a video game coach or a software debugger:

1. The Attempt: The AI tries to plan a path.
2. The Glitch: It suggests a move that breaks a rule (e.g., "Move East" into a wall).
3. The Localized Fix: Instead of restarting the whole game, the coach pauses right there and says, "Hey, look at this specific spot. If you are at (3,4) and there is a wall to the East, you cannot move East. You can only move North or South."
4. The Lesson: The AI adds this tiny, specific rule to its memory and tries again.

This is L-ICL. It doesn't show the AI the whole journey; it shows the AI one specific "doctest" (a tiny example of input and correct output) for the exact step where it failed.

Why This is a Game-Changer

The paper compares this "Spot-Check" method to the old "Whole Story" method (called RAG-ICL) and found some amazing results:

• Efficiency is King: The "Whole Story" method needed to show the AI 20,000 characters of text (a whole novel's worth of examples) to get a 9% success rate. The "Spot-Check" method (L-ICL) achieved an 89% success rate using only 2,000 characters of text.

  • Analogy: It's like teaching someone to bake a cake. The old way is to hand them a 500-page cookbook. The new way is to hand them a single sticky note that says, "If the oven is at 350, don't put the cake in for 10 minutes, or it burns." The sticky note is tiny, but it fixes the biggest problem.

• It Works Everywhere: They tested this on mazes, block-stacking puzzles (Sokoban), and even complex 3D-like block worlds. In almost every case, the AI got much better at following the rules.

• It Doesn't Need a Map: Surprisingly, the AI didn't even need to see a picture of the maze (the ASCII grid) to learn. It learned the rules just by seeing the "Spot-Check" examples. It learned the logic of the walls, not just the look of the walls.

The "Unit Test" Analogy

The authors use a great analogy from software engineering.

• Traditional Learning (Showing full paths) is like running an End-to-End Test. You run the whole program to see if it works. If it fails, you don't know which line of code broke.
• L-ICL is like a Unit Test. You test one tiny function at a time. "Does this specific button work?" "Yes." "Does this specific wall block movement?" "Yes." By hardening these tiny individual steps, the whole system becomes reliable.

The Limitation: Knowing the Rules vs. Being Smart

There is one catch. L-ICL makes the AI very good at following the rules (not walking through walls). But it doesn't necessarily make the AI a genius strategist.

• Analogy: L-ICL teaches the AI how to drive without hitting other cars. But it doesn't necessarily teach the AI how to win a race or find the fastest route through traffic.
• In complex puzzles (like Sokoban), the AI learned not to push boxes into corners (a rule), but it still sometimes struggled to plan the best sequence of moves to win the game. It became a rule-follower, but not always a master planner.

The Bottom Line

This paper solves a major headache for AI researchers: Why do smart AIs keep breaking simple rules?

The answer is that they were being taught with too much noise (whole stories) instead of clear, targeted feedback. By switching to L-ICL—which acts like a strict teacher correcting a student's specific math error on the spot rather than re-teaching the whole chapter—we can make AI planners significantly more reliable, using far less data and time.

It turns a clumsy, rule-breaking AI into a disciplined one, one tiny correction at a time.

Technical Summary

1. Problem Statement

Large Language Models (LLMs) have demonstrated strong reasoning capabilities in mathematics and coding but frequently fail at symbolic classical planning tasks. While LLMs can generate high-level strategies, they often produce plans that violate fundamental domain constraints (e.g., walking through walls in a maze, moving a block when the gripper is occupied).

The authors identify that existing approaches, such as In-Context Learning (ICL) with full solution trajectories or agentic scaffolding (e.g., ReAct, Tree of Thoughts), are inefficient at correcting these specific failures.

• The Bottleneck: LLMs fail not because they lack general knowledge, but because they cannot consistently apply specific domain constraints during inference.
• The Limitation of Current ICL: Providing complete solution trajectories (Retrieval-Augmented ICL) demonstrates that a plan works but leaves the validity of individual steps implicit. Consequently, even with large context windows (e.g., 20,000 characters), LLMs fail to infer the specific rules preventing constraint violations (e.g., only 9% success rate in gridworlds).

2. Methodology: Localized In-Context Learning (L-ICL)

The authors propose L-ICL, a method that iteratively augments prompts with localized, failure-driven corrections rather than complete trajectories. This approach is built upon Program Trace Prompting (PTP).

Core Components:

1. Program Trace Prompting (PTP):

   • The reasoning process is recast as generating an execution trace for a partially specified program.
   • The prompt includes documentation for subroutines (e.g., get_applicable_actions, apply_action) but no executable code.
   • The LLM must infer the correct behavior for these subroutines based on context and examples.

2. The L-ICL Loop (Training Phase):

   • Trace Generation: The LLM generates a planning trace for a training problem.
   • First Failure Identification: A symbolic oracle (verifier) analyzes the trace to find the first step where the LLM's output violates a domain constraint.
   • Localized Correction: The oracle provides the correct output for that specific input. A minimal input-output example (formatted as a Python doctest) is generated.
   • Prompt Augmentation: This specific example is inserted into the documentation of the failing subroutine in the prompt.
   • Iteration: This process repeats over a set of training problems, accumulating a bank of targeted corrections that "harden" the prompt against specific types of errors.

3. Inference Phase:

   • Crucially, the oracle is only required during training.
   • At test time, the LLM receives the augmented prompt containing the accumulated localized corrections and generates a plan in a single forward pass without external tools or iterative self-correction.

3. Key Contributions

1. Diagnosis of Failure Modes: The paper provides empirical evidence that constraint violations are the dominant failure mode for LLM planners, even when full domain specifications are provided.
2. L-ICL Framework: Introduction of a method that improves planning validity by injecting minimal, targeted examples for specific failing steps, rather than full trajectories.
3. Superior Efficiency: Demonstrates that L-ICL achieves higher performance with significantly less context (2,000 characters of targeted corrections vs. 20,000 characters of full trajectories).
4. Generalization: The method is shown to work across multiple planning domains (Gridworld, Mazes, Sokoban, BlocksWorld) and various LLM architectures (DeepSeek V3, Claude Haiku/Sonnet).
5. Open Source: Release of a benchmark suite and code to facilitate future research.

4. Experimental Results

The authors evaluated L-ICL on a progressive suite of domains, ranging from simple navigation to complex multi-object manipulation.

• Performance Gains:

  • 8×8 Gridworld: Zero-shot prompting achieved 0% success. L-ICL with only 60 training examples achieved 89% success and 89% validity.
  • 10×10 Maze: L-ICL improved success rates from <5% (baselines) to 27%, with validity reaching 57%.
  • Sokoban: L-ICL improved validity from 19% to 46%, though success remained lower (20%) due to the complexity of strategic planning (avoiding trap states).
  • BlocksWorld: Success improved from 48% to 66%.

• Comparison with Baselines:

  • L-ICL significantly outperformed RAG-ICL (Retrieval-Augmented ICL). While RAG-ICL with 20k characters of retrieved trajectories achieved only 9% success, L-ICL with ~2k characters achieved 89%.
  • L-ICL outperformed agentic methods like ReAct, Self-Refine, and Tree of Thoughts, which often failed to correct constraint violations effectively.

• Sample Efficiency:

  • L-ICL converges quickly, typically reaching peak performance with 30–60 training examples.
  • It demonstrates strong Out-of-Distribution (OOD) generalization, transferring constraints learned on 10×10 mazes to 15×15 mazes.

• Ablation Studies:

  • Visual Scaffolding: L-ICL does not strictly require ASCII grid visualizations; it can learn constraints purely from text-based examples, though visual grids accelerate early learning.
  • Architecture Agnostic: The method yields substantial gains across DeepSeek V3, V3.1, and Claude 4.5 models.

5. Significance and Implications

• Unit Testing Analogy: The authors draw a parallel between L-ICL and unit testing in software engineering. Just as unit tests "harden" individual code subroutines, L-ICL hardens individual reasoning steps. Full trajectories are likened to end-to-end tests, which are less efficient for fixing specific bugs.
• Decomposition of Planning: The results suggest a clear separation between Constraint Satisfaction (generating valid actions) and Strategic Reasoning (choosing the optimal path). L-ICL effectively solves the former, providing a reliable foundation upon which higher-level strategic reasoning can be built.
• Practical Impact: L-ICL offers a practical, low-cost solution for improving LLM reliability in planning tasks without requiring fine-tuning or complex inference-time search. It shifts the burden from exhaustive prompt engineering to a data-driven, failure-driven refinement process.

In conclusion, the paper argues that the path to reliable LLM planning lies not in larger models or more complex reasoning chains, but in making implicit domain constraints explicit through localized, failure-driven examples.