Agentic LLM Planning via Step-Wise PDDL Simulation: An Empirical Characterisation

Dit artikel presenteert PyPDDLEngine, een open-source PDDL-simulatieengine die LLM's in staat stelt om via stapsgewijze interactie te plannen, en toont aan dat deze agentische aanpak een bescheiden prestatievoordeel biedt ten opzichte van directe LLM-planning, maar aanzienlijk onderpresteert ten opzichte van klassieke symbolische methoden zoals Fast Downward.

De kern

Stel je voor dat je een robot wilt bouwen die een kamer moet opruimen. De robot moet weten welke blokken waarheen moeten, welke blokken op elkaar gestapeld kunnen worden en welke niet. Dit noemen we "planning".

Deze paper onderzoekt een interessante vraag: Kunnen moderne AI-modellen (zoals de slimme chatbots die we vandaag kennen) deze taken beter plannen dan de oude, traditionele methoden? En nog belangrijker: helpt het als we de AI laten "proberen, kijken wat er gebeurt, en dan opnieuw proberen" (zoals een mens dat zou doen), in plaats van ze direct een volledig plan te laten bedenken?

Hier is de uitleg, vertaald naar alledaagse taal met een paar creatieve vergelijkingen.

1. De Twee Manieren van Plannen

De onderzoekers hebben twee manieren getest om de AI te laten plannen:

• De "Directe" Manier (De Dromer):
  Stel je voor dat je iemand vraagt: "Bedenk een route van Amsterdam naar Rome." Die persoon denkt even na en schrijft direct een volledig reisplan op: "Eerst trein, dan bus, dan vliegtuig..."

  • Het probleem: Als er een fout in staat (bijvoorbeeld: de bus rijdt niet op die dag), moet de persoon het hele plan weggooien en opnieuw beginnen. Er is geen tussentijdse controle.
  • In de paper noemen ze dit Direct LLM Planning. De AI schrijft het hele plan in één keer op.

• De "Agentische" Manier (De Wandeltocht met Kompas):
  Nu vragen we dezelfde persoon: "Lopen we samen naar Rome. Stap voor stap. Ik zeg je waar je bent, en jij beslist de volgende stap."

  • De AI doet één stap, kijkt of het lukt, en beslist dan pas de volgende. Als ze merken dat ze in een doodlopende straat zitten, kunnen ze terugspringen naar het begin en een andere route proberen.
  • In de paper noemen ze dit Agentic LLM Planning. Ze gebruiken een speciaal hulpmiddel (PyPDDLEngine) dat fungeert als een simulatie-systeem.

2. Het Experiment: De Blokkenwereld

Om dit te testen, gebruikten ze een klassiek puzzelspel: Blocksworld.
Stel je een tafel voor met verschillende blokken. De opdracht is: "Zet het rode blok op het blauwe blok."

• Er waren 102 verschillende puzzels, van heel makkelijk tot heel moeilijk.
• Ze gaven alle methoden precies 3 minuten (180 seconden) de tijd om een oplossing te vinden.

3. De Resultaten: Wie deed het beter?

De onderzoekers vergeleken de AI met de "gouden standaard" van robotica: een oude, zeer snelle en logische computerprogramma (Fast Downward).

• De Oude Computer (Fast Downward):
  Deze deed het uitstekend. Hij loste 85% van de puzzels op. Hij is als een super-rekenmachine die geen fouten maakt, maar ook geen creativiteit heeft.
• De AI (Direct):
  Deze loste 64% op.
• De AI (Agentisch - Stap voor stap):
  Deze loste 67% op.

De verrassing: De "stap-voor-stap" AI deed het iets beter dan de "directe" AI, maar het verschil was klein (slechts 3%). En het kostte de AI 5,7 keer meer rekenkracht (en dus geld/energie) om die kleine winst te behalen.

4. Waarom werkt het niet zo goed als bij het programmeren?

Dit is het meest interessante deel van de paper. De onderzoekers vergelijken dit met AI die code schrijft (zoals een programmeur).

• Bij programmeren: Als de AI een fout maakt, geeft de computer een duidelijke foutmelding: "Deze regel werkt niet." Dit is een externe, objectieve feedback. De AI weet precies wat er mis is.
• Bij dit plan (Blocksworld): De AI doet een stap en ziet: "Oké, het blok is verplaatst." Maar de AI krijgt geen signaal dat zegt: "Je bent nu dichter bij het doel" of "Je bent op het verkeerde pad". De AI moet zelf raden of het goed gaat.

De Metafoor:
Stel je voor dat je in het donker door een labyrint loopt.

• Bij programmeren: Iemand roept je toe: "Je bent 10 meter van de uitgang verwijderd!" of "Je loopt tegen een muur!" (Dit is de externe feedback).
• Bij dit experiment: Je loopt in het donker. Je voelt een muur, maar je weet niet of je dichter bij de uitgang bent of juist verder weg. Je moet het zelf raden.
  De onderzoekers concluderen dat de AI in het donker (zonder externe feedback) niet veel beter wordt door stap-voor-stap te lopen. Ze raken vaak in de war en denken dat een probleem onoplosbaar is, terwijl het dat niet is.

5. De "Geheugen"-Theorie

Er is nog een opvallend punt. De AI maakte soms zelfs kortere routes dan de super-snelle oude computer, zelfs als die oude computer de tijd had om zijn plan te verbeteren.

De onderzoekers denken dat dit komt omdat de AI de oplossingen uit zijn hoofd heeft geleerd (uit zijn trainingsdata), in plaats van echt te "redeneren".

• Het is alsof de AI een boek heeft gelezen over "Hoe je blokken stapelt" en de antwoorden uit het hoofd kent.
• Als ze een nieuwe, rare puzzel krijgen die ze niet kennen, zakken ze direct in elkaar. Ze zijn geen echte planners, maar slimme "herhalers" van bekende patronen.

Conclusie: Wat betekent dit voor de toekomst?

De paper zegt eigenlijk: "AI is slim, maar niet slim genoeg om zichzelf te controleren zonder hulp."

Als we robots willen bouwen die echt zelfstandig taken uitvoeren, kunnen we niet alleen vertrouwen op de AI om te zeggen "dit werkt wel". We hebben een systeem nodig dat de robot duidelijke signalen geeft: "Je bent op de goede weg" of "Stop, je maakt een fout".

Zonder die duidelijke, externe feedback (zoals een foutmelding in code of een sensor die aangeeft dat een blok is gevallen), blijft de AI steken in het raden en is het "stap-voor-stap" plannen niet veel beter dan het direct bedenken van een plan.

Kort samengevat:
De AI is als een student die de antwoorden uit het hoofd heeft geleerd. Als je hem een vraag stelt die hij kent, geeft hij het perfecte antwoord. Maar als je hem vraagt om stap voor stap een nieuw probleem op te lossen zonder dat iemand hem vertelt of hij het goed doet, raakt hij snel in de war. Voor echte robots hebben we dus niet alleen een slimme "hoofd", maar ook goede "ogen" en "oren" die de AI vertellen of hij op de goede weg is.

Technische samenvatting

1. Probleemstelling

Autonome robotsystemen vereisen taakplanning: het sequentiëren van acties om van een initiële staat naar een doeltoestand te komen. Klassieke planners gebruiken systematische symbolische zoekalgoritmen over formele domeinmodellen. Er is echter een groeiende interesse in het gebruik van Grote Taalmodellen (LLMs) als planners, die wereldkennis en gezond verstand toepassen zonder domeinspecifiek programmeren.

De centrale vraag is of LLMs als levensvatbare planners kunnen fungeren en of een agente benadering (interactief, stap-voor-stap met feedback) superieur is aan directe generatie (het genereren van een volledig plan in één keer). Bestaand onderzoek toont aan dat LLMs vaak falen bij het genereren van uitvoerbare plannen in symbolische domeinen en dat hun prestaties vaak gebaseerd zijn op het herinneren van trainingsdata in plaats van echt redeneren. Er is echter weinig systematisch onderzoek gedaan naar het uitvoeren van een LLM als een agent binnen een PDDL-simulatieomgeving (Planning Domain Definition Language), waar de LLM één actie per keer uitvoert, de nieuwe staat observeert en kan terugkeren (resetten) als een traject niet productief is.

2. Methodologie

PyPDDLEngine en MCP Interface

De auteurs presenteren PyPDDLEngine, een open-source Python-bibliotheek die een PDDL-simulatie-engine implementeert. In tegenstelling tot klassieke planners (zoals Fast Downward) die een volledig plan berekenen, of validators die alleen een voltooid plan accepteren of verwerpen, stelt PyPDDLEngine de LLM in staat om interactief te werken.

• Interface: De engine is verpakt als een Model Context Protocol (MCP) server, waardoor LLMs planning-acties kunnen uitvoeren via gestandaardiseerde tool-calls.
• Beschikbare operaties: De LLM kan een sessie initialiseren, de huidige staat queryen, toepasbare acties opvragen, een enkele actie uitvoeren, resetten naar de startstaat, de actiegesciedenis bekijken en een compleet plan valideren.
• Rol van de LLM: De LLM fungeert hier als het zoekbeleid (search policy) dat de PDDL-statenruimte navigeert, in plaats van als een generator die een plan voor een klassieke solver vertaalt.

Experimenteel Protocol

De studie evalueerde vier benaderingen op 102 Blocksworld-voorbeelden uit de International Planning Competition (IPC) binnen een uniform tijdsbudget van 180 seconden:

1. Fast Downward (lama-first): Een klassieke, hebberige (greedy) satisficing planner.
2. Fast Downward (seq-sat-lama-2011): Een klassieke planner die iteratief de planlengte verbetert binnen het tijdsbudget.
3. Directe LLM-planning: Claude Haiku 4.5 genereert een volledig plan in één prompt. Bij mislukking wordt het model opnieuw geprompt zonder feedback.
4. Agente LLM-planning: Claude Haiku 4.5 gebruikt PyPDDLEngine om actie voor actie te kiezen, observeert de staat, en kan resetten bij een doodlopende weg.

De evaluatie mat succespercentages, planlengte (op gezamenlijk opgeloste instances), faalmodi en tokenkosten.

3. Belangrijkste Bijdragen

1. PyPDDLEngine: Een open-source tool die de infrastructuur levert om LLMs als interactieve zoekagenten in een formele PDDL-omgeving te testen, wat reproduceerbaar onderzoek mogelijk maakt.
2. Empirische Karakterisering: Een uitgebreide vergelijking tussen directe en agente LLM-planning versus klassieke baselines. De studie kwantificeert de kosten, het succes en de afhankelijkheid van moeilijkheidsgraad.
3. Inzicht in Feedback-mechanismen: Het paper identificeert dat de beperkte winst van agente planning in dit domein te wijten is aan het ontbreken van extern gegrondde feedback (zoals compilerfouten in codering), waardoor de agent zijn eigen voortgang moet beoordelen zonder externe verificatie.

4. Resultaten

• Succespercentages:

  • Fast Downward: 85,3% succes (oplost 87 van de 102 instances).
  • Directe LLM: 63,7% succes.
  • Agente LLM: 66,7% succes.
  • De agente benadering levert een consistente maar bescheiden verbetering van 3% ten opzichte van directe generatie.

• Kosten:

  • De agente benadering is aanzienlijk duurder: 5,7x hogere tokenkosten per oplossing vergeleken met directe generatie.

• Planlengte:

  • Op de instances die door alle vier de methoden zijn opgelost, produceren beide LLM-benaderingen kortere plannen dan de klassieke seq-sat-lama-2011 (die specifiek is ontworpen om plannen te verkorten).
  • Dit suggereert dat de LLMs waarschijnlijk trainingsdata-herinnering gebruiken in plaats van echt te zoeken, aangezien ze zonder iteratieve verbeteringsmechanismen toch betere resultaten behalen dan een klassieke planner die wel iteratieert.

• Faalmodi:

  • De agente LLM toonde een uniek gedrag: op 6 instances stopte de agent vroegtijdig met het oordeel dat het probleem onoplosbaar was ("early exit"). Op 4 van deze 6 gevallen bleek de directe LLM wel een oplossing te vinden, wat aantoont dat de agent zijn eigen voortgang verkeerd inschatte.

• Zware Instances:

  • Op de 15 moeilijkste instances (waar Fast Downward time-out gaf), loste de agente LLM slechts 3 extra instances op die de directe LLM niet kon oplossen, en miste hij de meeste andere.

5. Betekenis en Conclusie

Het paper concludeert dat agente interactie op zichzelf niet voldoende is om de planningprestaties van LLMs significant te verbeteren in domeinen zonder externe validatie.

• Feedback-kwaliteit: Het succes van agente systemen in software-engineering (waar agents compilerfouten en testfailures zien) is gebaseerd op extern gegrondde, objectieve feedback. In PDDL-simulatie is de feedback "zelf gegenereerd" (de engine zegt alleen of een actie geldig was, niet of het dichterbij het doel is). Zonder extern signaal kan de LLM zijn eigen fouten niet betrouwbaar corrigeren.
• Memoriseren vs. Redeneren: Het feit dat LLMs kortere plannen genereren dan een iteratieve klassieke planner, en dat hun prestaties instorten bij syntactische herschrijving van acties, wijst sterk op herinnering van trainingsdata in plaats van generaliseerbaar planningsvermogen.
• Implicaties voor Robotica: Voor de inzet van LLMs in robotsystemen is het cruciaal dat de perceptie-laag niet alleen de huidige staat rapporteert, maar ook signaal geeft over voortgang (of falen) richting het doel. De prestatieplafond van een LLM-planner wordt bepaald door de kwaliteit van deze feedback, niet alleen door de wereldkennis van het model.

Kortom: LLM-planners fungeren momenteel meer als adaptieve navigators in bekende probleemruimtes dan als universele planners, en de voordelen van een agente benadering zijn sterk afhankelijk van de aanwezigheid van objectieve, externe feedbacksignalen.