Localizing and Correcting Errors for LLM-based Planners

Deze paper introduceert Localized In-Context Learning (L-ICL), een methode die de prestaties van LLM-planners aanzienlijk verbetert door gefocuste correcties voor specifieke fouten toe te voegen, waardoor het aantal geldige plannen in diverse domeinen significant toeneemt ten opzichte van bestaande technieken.

De kern

Samenvatting: Hoe we LLM's leren om niet door muren te lopen

Stel je voor dat je een zeer slimme, maar nogal ongeduldige robot hebt die alles kan lezen en schrijven. Deze robot is een meester in wiskunde en programmeren, maar als je hem vraagt om een plan te maken om door een doolhof te lopen of blokken te stapelen, faalt hij vaak op de gekste manieren. Hij probeert bijvoorbeeld gewoon door een muur te lopen, of hij pakt een blok terwijl zijn hand al vol zit.

De onderzoekers van dit paper (Aditya Kumar en William Cohen) hebben een oplossing bedacht die ze L-ICL noemen. Laten we uitleggen hoe dit werkt met een paar simpele vergelijkingen.

Het Probleem: De "Grote Boek" aanpak werkt niet

Stel je voor dat je iemand wilt leren hoe je een doolhof loopt.

• De oude manier (RAG-ICL): Je geeft die persoon een heel dik boek vol met verhalen van andere mensen die het doolhof succesvol hebben gelopen. Het probleem is dat het boek alleen laat zien dat ze het hebben gehaald, maar niet waarom ze op punt X niet naar rechts mochten gaan. De lezer moet zelf raden wat de regels zijn. Het resultaat? De persoon leest het hele boek, maar loopt toch tegen de muur aan.
• De nieuwe manier (L-ICL): Je geeft geen boek. Je laat de persoon gewoon proberen. Zodra hij tegen de muur loopt, stop je hem direct en zeg je: "Hé, op dit specifieke punt mag je niet naar rechts, want daar is een muur. Hier is een klein kaartje met de juiste richting." Je geeft dus geen heel verhaal, maar alleen een specifiek correctiekaartje voor de fout die hij net maakte.

De Oplossing: "Unit Tests" voor een robot

De onderzoekers vergelijken hun methode met unit testing in softwareontwikkeling.

• In de softwarewereld test je niet alleen of het hele programma werkt (eindtest), maar test je ook elk klein stukje code apart om te zien of het klopt.
• L-ICL doet precies dat voor de robot. Als de robot een fout maakt (bijvoorbeeld: "Ik ga door muur"), voegen ze een klein voorbeeld toe aan de instructies die de robot krijgt. Dit voorbeeld zegt: "Als je hier staat, zijn deze bewegingen verboden."

Dit gebeurt iteratief:

1. De robot probeert een plan.
2. Een slimme "scheidsrechter" (een simpele computer) kijkt mee en ziet de eerste fout.
3. De scheidsrechter maakt een klein correctie-voorbeeld (een "doctest") en plakt dit in de instructies van de robot.
4. De robot probeert het opnieuw, nu met die extra kennis.
5. Dit herhaalt zich totdat de robot de regels van het spel perfect begrijpt.

Waarom is dit zo slim?

1. Efficiëntie: Het is veel sneller dan een heel boek lezen. Met slechts 60 kleine correcties (in plaats van duizenden woorden aan voorbeelden) haalde de robot 89% succes in een doolhof, terwijl de beste andere methoden maar 59% haalden.
2. Leren van fouten: De robot leert niet door te zien hoe het moet, maar door te zien wat niet mag. Dit is vaak effectiever.
3. Alles werkt: Het werkt voor verschillende soorten robots (LLM-modellen) en in verschillende spelletjes, van simpele wandelingen tot complexe spelletjes als Sokoban (waar je dozen moet duwen).

De Grootte van de Prestatie

Op een simpele 8x8 rooster (een klein doolhofje) haalde de robot zonder hulp 0% succes. Hij liep gewoon door muren.
Met de L-ICL methode (na slechts 60 trainingen) haalde hij 89% succes. Hij leerde niet alleen de regels, maar kon ze ook toepassen.

Wat kan hij nog niet?

De methode is fantastisch om te leren wat mag en wat niet mag (bijvoorbeeld: niet door muren lopen). Maar het helpt minder bij het bedenken van de beste strategie.

• Vergelijking: Stel je voor dat je een schaker bent. L-ICL leert je dat je je koning niet in het schaakmat mag zetten (de regel). Maar het leert je niet per se welke zet je moet doen om je tegenstander te verslaan (de strategie). In complexe spelletjes zoals Sokoban is het dus nog steeds lastig om de perfecte route te vinden, zelfs als je de regels kent.

Conclusie

De kernboodschap is: Kwaliteit van voorbeelden is belangrijker dan kwantiteit.
In plaats van een robot te overladen met duizenden voorbeelden van perfecte oplossingen, is het veel effectiever om hem te laten falen en hem dan direct de juiste les te geven voor die ene specifieke fout. Het is alsof je een leerling niet een heel jaar theorie laat lezen, maar hem direct corrigeert op het moment dat hij een fout maakt. Zo wordt de robot betrouwbaarder en slimmer, zonder dat we hem duizenden pagina's hoeven te laten lezen.

Technische samenvatting

Titel: Localizing and Correcting Errors for LLM-based Planners

Auteurs: Aditya Kumar en William Cohen (Carnegie Mellon University)

---

1. Het Probleem

Grote Taalmodellen (LLMs) tonen sterke redeneervermogens in domeinen zoals wiskunde en codering, maar falen vaak bij symbolische klassieke planningstaken. Hoewel LLMs instructies over domeinbeperkingen (bijvoorbeeld "een agent kan niet door muren lopen") ontvangen, negeren ze deze consistent in hun gegenereerde plannen.

• De Kern van het Falen: LLMs genereren plannen die fundamenteel in strijd zijn met de regels van de omgeving (bijvoorbeeld door muren lopen in een labyrint of blokken oppakken terwijl de grijper al bezet is).
• Beperkingen van Bestaande Aanpakken:
  • Zero-Shot: Zonder voorbeelden falen modellen bijna volledig (0% succes op eenvoudige taken).
  • Volledige Trajecten (ICL/RAG): Het toevoegen van volledige oplossingspaden (complete trajecten) als voorbeelden in de prompt helpt weinig. Dit toont dat een oplossing werkt, maar verbergt waarom individuele stappen geldig zijn. Zelfs met 20.000 tekens aan voorbeelden blijft het succespercentage laag (9%).
  • Agente Methodes: Methoden zoals ReAct of Self-Refine verbeteren de prestaties enigszins, maar genereren nog steeds veel ongeldige plannen.

De auteurs concluderen dat LLMs moeite hebben om de specifieke, impliciete domeinkennis consistent toe te passen, zelfs als deze expliciet in de instructies staat.

---

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

De auteurs introduceren L-ICL, een methode die fouten lokaliseert en corrigeert door gerichte, minimale voorbeelden toe te voegen in plaats van volledige oplossingen.

Kernprincipes:

1. Program Trace Prompting (PTP): De methode bouwt voort op PTP, waarbij redeneren wordt omgezet in het genereren van een "uitvoeringstrace" voor een deels gespecificeerd programma. De prompt bevat documentatie voor subroutines (functies) zonder de implementatiecode. De LLM moet het gedrag van deze functies infereren.
2. Lokalisatie van Fouten: In plaats van het hele plan te verwerpen, analyseert het systeem de gegenereerde trace om de eerste stap te vinden waar een domeinbeperking wordt geschonden (de eerste "fail").
3. Gerichte Correctie: Voor deze specifieke fout wordt een minimaal input-output voorbeeld gegenereerd door een "orakel" (een symbolische planner of simulator).
   • Voorbeeld: Als de LLM probeert naar het oosten te bewegen vanuit positie (3,4) terwijl daar een muur staat, voegt L-ICL een voorbeeld toe aan de prompt: get_applicable_actions((3,4)) -> ['move north', 'move south'].
4. Iteratief Accumuleren: Dit proces wordt herhaald over een reeks trainingsproblemen. De correcties worden opgeslagen en toegevoegd aan de prompt-documentatie van de betreffende subroutines. Hierdoor "verhardt" de prompt geleidelijk tegen specifieke soorten fouten.

Belangrijk onderscheid:

• Traditionele ICL: Toont volledige trajecten (end-to-end tests).
• L-ICL: Toont specifieke input-output paren voor individuele stappen (unit tests). Dit maakt de kennis expliciet op het punt van toepassing.

---

3. Belangrijkste Bijdragen

1. Diagnose van Fouten: Het paper kwantificeert dat schending van domeinbeperkingen de dominante faalmodus is voor LLM-planners, zelfs op eenvoudige taken.
2. Introductie van L-ICL: Een nieuwe methode die planning validiteit verbetert door gefaalde stappen te corrigeren met lokale voorbeelden.
3. Efficiëntie: L-ICL presteert aanzienlijk beter dan methoden die volledige trajecten gebruiken, zelfs met 10x minder context (2.000 tekens tegenover 20.000 tekens).
4. Generalisatie: De methode werkt over meerdere domeinen (Gridworld, Mazes, Sokoban, BlocksWorld) en verschillende LLM-architecturen (DeepSeek V3, Claude 4.5).
5. Open Source: De auteurs publiceren hun benchmark-suite en code om toekomstig onderzoek te faciliteren.

---

4. Resultaten

De experimenten tonen dramatische verbeteringen ten opzichte van baselines:

• 8x8 Gridworld:
  • Zero-Shot: 0% succes.
  • Beste Baseline (Self-Consistency): 45% succes.
  • L-ICL (met 60 voorbeelden): 89% succes en 89% validiteit.
• Efficiëntie: L-ICL bereikt een hoger succespercentage met slechts ~5.000 tekens context, terwijl RAG-ICL (Retrieval-Augmented ICL) met 20.000 tekens slechts 16% succes behaalt.
• Domeinoverdracht:
  • Mazes: Succes steeg van 5% (baselines) naar 27% (L-ICL).
  • Sokoban: Hoewel L-ICL de validiteit sterk verbetert (van 19% naar 46%), blijft er een kloof naar succes (20%). Dit suggereert dat L-ICL goed is in het leren van fysieke beperkingen, maar strategisch redeneren (het vermijden van valstrikken op lange termijn) nog steeds een uitdaging is.
  • BlocksWorld: Succes steeg van 48% naar 66%, wat aantoont dat de methode ook werkt voor relationele beperkingen, niet alleen ruimtelijke.
• Architectonische Generalisatie: De methode werkt effectief op DeepSeek V3, V3.1, Claude Haiku 4.5 en Claude Sonnet 4.5.

---

5. Betekenis en Conclusie

De paper biedt een nieuw perspectief op het verbeteren van LLM-planning:

• Unit Testing voor LLMs: L-ICL fungeert als een vorm van "unit testing" voor redeneerstappen. Het maakt impliciete kennis expliciet op het moment dat de fout optreedt, in plaats van te hopen dat het model het uit een lang traject afleidt.
• Proces vs. Resultaat: Het paper benadrukt dat het garanderen van de geldigheid van individuele stappen (validiteit) een noodzakelijke voorwaarde is, maar niet altijd voldoende is voor strategisch succes (zoals het vermijden van onomkeerbare valstrikken in Sokoban).
• Praktische Toepassing: L-ICL biedt een praktische, sample-efficiënte manier om LLMs te "hardened" tegen domeinspecifieke fouten zonder dat er fine-tuning nodig is. Het reduceert de last van prompt-engineering, omdat de systemen de beperkingen zelf kunnen ontdekken via foutgedreven correcties.

Conclusie: L-ICL lost het probleem van LLM-planning niet volledig op (strategisch redeneren blijft lastig), maar het biedt een robuuste fundamentele laag die zorgt dat voorgestelde acties voldoen aan de fysica en regels van de wereld, wat een essentiële stap is voor betrouwbare agente systemen.