Technische Samenvatting: Grounded Iterative Language Planning (GILP)

1. Probleemstelling

Het artikel behandelt de uitdaging van hallucinatie-propagatie bij taken met een lange horizon die worden uitgevoerd door Large Language Model (LLM) agenten. In standaard agent-gebaseerde planning (bijv. ReAct, Chain-of-Thought) fungeert het LLM zowel als de planner als het agent-gebaseerde wereldmodel. Het genereert een actie en voorspelt tegelijkertijd de volgende staat (een "delta") in natuurlijke taal of gestructureerde JSON.

Het kernprobleem is dat fouten in deze staat-voorspellingen semantische hallucinaties zijn (bijv. beweren dat een taak is voltooid terwijl dat niet zo is, of een afhankelijkheid negeren). In tegen tegenstelling tot geparametriseerde modellen zijn deze fouten niet eenvoudig te kwantificeren met standaard regressieverliesfuncties (zoals MSE). Zodra een gehalucineerde staat-atoom in het contextvenster terechtkomt, propageert dit door opeenvolgende stappen, wat een cascade van ongeldige acties en taalfalen veroorzaakt. Het artikel merkt op dat hoewel agent-gebaseerde modellen uitblinken in semantisch redeneren, hun foutpercentages significant toenemen over lange horizonten (bijv. het bereiken van een foutkans per stap van 0,393 bij stap 10 in experimenten).

Daartegenover bieden geparameteriseerde wereldmodellen (getrainde transitie-voorspellers) meetbare, gesuperviseerde foutmetrieken (NodeMSE, delta-accuratesse), maar missen ze vaak de semantische flexibiliteit om over complexe, nieuwe doelen te redeneren, wat resulteert in lagere zelfstandige succespercentages.

2. Methodologie: Grounded Iterative Language Planning (GILP)

GILP is een hybride architectuur die is ontworpen om de semantische redeneerkracht van API-gebaseerde LLM-agenten te combineren met de meetbare transitie-signalen van een kleine, getrainde geparametriseerde backbone. Het systeem werkt in een iteratieve lus met vier afzonderlijke fasen:

Fase 1: Parameterized Skeleton Scoring

Een klein, getraind neuraal netwerk (de "backbone", doorgaans een Graph Neural Network of MLP) ontvangt de huidige staat $G_t$ en kandidaat-acties $A_t$. Het voorspelt:

• Actie-geldigheid ($p_{valid}$)
• Staat-delta's ($\hat{\Delta}G$)
• Risico ($\hat{\rho}$)
• Waarde ($\hat{U}$)
• Voltooiingskans ($\hat{p}_{done}$)

De backbone comprimeert de kandidaat-actieset tot een "skeleton" (top-$k$ acties op basis van waarde en risico) om de overhead van het contextvenster te verminderen.

Fase 2: LLM Draft

De LLM-agent ontvangt de geserialiseerde staat, het doel en het skeleton uit Fase 1. Het ontwerpt een actie en een verbeelde volgende-staat-delta ($\tilde{\Delta}_t$) in gestructureerde JSON. Deze fase maakt gebruik van de redeneerkracht van het LLM.

Fase 3: Consistency Gate en Correctieve Re-prompting

Dit is het kernmechanisme voor het reduceren van hallucinaties. Het systeem vergelijkt de verbeelde delta van het LLM ($\tilde{\Delta}_t$) met de voorspelde delta van de backbone ($\hat{\Delta}G$) met behulp van Jaccard-gelijkenis op de set van gewijzigde nodes.

• Hoge Consistentie ($\ge 0,70$): De actie wordt geaccepteerd.
• Medium Consistentie ($0,30 \le cons < 0,70$): De actie wordt geaccepteerd maar lager gerankt.
• Lage Consistentie ($< 0,30$): Een correctieve re-prompt wordt geactiveerd. Het systeem stuurt een gerichte boodschap naar het LLM waarin expliciet de nodes worden vermeld waar de backbone en het LLM van mening verschillen (bijv. "Node X: backbone voorspelt 'pending', jij verbeeldde 'completed'"). Het LLM wordt gevraagd de actie of de staat-delta te herzien. Deze correctie is beperkt tot één revisie per stap om de kosten te beheersen.

Fase 4: Risk Gate

Als de voorspelde risico van de backbone voor de gekozen actie een drempelwaarde overschrijdt ($\rho_{th} = 0,65$), wordt een derde LLM-call getriggerd om de agent te waarschuwen en de actieruimte te beperken tot opties met een laag risico, om catastrofale fouten te voorkomen (bijv. het herhalen van een taak met een onopgeloste oorzaak).

3. Belangrijkste Bijdragen

1. Vergelijkend Kader: Het artikel kadert langdurige planning als een afruil tussen twee families van wereldmodellen: flexibele maar hallucinatiegevoelige agent-gebaseerde modellen, en meetbare maar semantisch zwakkere geparametriseerde modellen.
2. Operationele Hallucinatiemetrieken: Het definieert specifieke metrieken voor agent-gebaseerde fouten die verder gaan dan standaard verliesfuncties:
   • Hallucinated-State Rate (HSR): Het deel van de verbeelde staat-atomen dat afwijkt van de grondwaarheid.
   • Propagation Depth (PD): Het gemiddelde aantal daaropvolgende stappen dat geconditioneerd is aan een gehalucineerd atoom.
   • Error-Explosion Slope (EES): De snelheid waarmee fouten zich over de tijd voortplanten.
3. GILP Architectuur: De introductie van een hybride systeem dat een kleine, getrainde backbone gebruikt, niet om de taak op te lossen, maar om een "grounding signaal" (geldigheid, delta, risico) te leveren om de staat-hallucinaties van het LLM via een consistency gate te corrigeren.
4. Empirische Validatie: Uitgebreide evaluatie over vier grafiek-gestructureerde benchmarks (TaskGraph, ToolChain, ResourceAlloc, RepairFlow) en real-world API-aanroepen (GPT-4o-mini).

4. Experimentele Resultaten

De resultaten zijn afgeleid van een gekalibreerde gedragssimulator (gevalideerd tegen echte GPT-4o-mini runs) en directe API-testen.

• Succespercentage (SR): GILP bereikt een succespercentage van 0,838 op de gecombineerde benchmarks, wat aanzienlijk beter presteert dan de beste agent-only baseline (Agent-Replan met 0,668) en geparametriseerde planners alleen (0,565–0,625).
• Reductie van Hallucinaties:
  • Simulator: HSR daalt van 0,205 (Agent-Replan) naar 0,079 (GILP).
  • Real API (GPT-4o-mini): HSR daalt van 0,176 naar 0,035 (een relatieve reductie van 80%).
• Prestaties op Lange Horizon: Voor taken met een horizon $H > 10$ stort het succespercentage van de agent-only baseline in naar 0,471, terwijl GILP 0,758 behoudt.
• Kostenefficiëntie: GILP voegt ongeveer 22% extra LLM-calls toe per stap (door incidentele correctie en risk gates), maar vermindert het totaal aantal benodigde tokens per opgeloste taak vergeleken met ongecorrigeerde agenten omdat het meer episodes oplost.
• Backbone Sterkte: De geparametriseerde backbone hoeft geen sterke planner te zijn. Zelfs een zwakke MLP (standalone SR 0,509) verbetert het hybride systeem aanzienlijk (SR 0,768) wanneer deze als grounding signaal wordt gebruikt.
• Multi-API Robuustheid: GILP egaliseert de prestaties over verschillende LLM API's (GPT-4o-mini, Claude-3-Haiku, Gemini-1.5-Flash, Llama-3-8B), waardoor de HSR-variantie afneemt en open-source modellen competitief worden met propriëtaire modellen wanneer ze gegrond zijn.

5. Betekenis en Claims

Het artikel claimt dat de primaire bijdrage niet de superioriteit van het geparametriseerde model is, maar de taakverdeling die het mogelijk maakt. De agent behoudt zijn semantische redenering en flexibiliteit, terwijl de geparametriseerde backbone een "goedkoop, meetbaar en controleerbaar" signaal levert om staat-hallucinaties te detecteren en te corrigeren.

De auteurs benadrukken dat:

• Hallucinatie een propagatieprobleem is: Eén vals token kan een hele traject ongeldig maken; GILP onderbreekt deze cascade.
• Kleine training volstaat: Een kleine, getrainde backbone is voldoende om een API-gebaseerde agent te gronden; het hoeft de redeneerkracht van de agent niet te vervangen.
• Gerichte correctie efficiënt is: De consistency gate triggert alleen re-prompts wanneer dat nodig is (ongeveer 22% van de stappen), waardoor de hoge kosten van het verifiëren van elke stap met een groot model worden vermeden.

Het artikel concludeert dat GILP een praktisch pad biedt om hallucinaties in autonome agenten te verminderen zonder de redeneerkracht van large language models op te offeren, waarbij een hoog succespercentage wordt behaald met slechts een marginale toename in computationele kosten.