💻 computer science

GraphPlanner: Graph Memory-Augmented Agentic Routing for Multi-Agent LLMs

Het paper introduceert GraphPlanner, een door versterkingslering geoptimaliseerde routering voor multi-agent LLM-systemen die gebruikmaakt van een heterogene grafgeheugenstructuur om dynamische workflows te genereren, wat leidt tot aanzienlijk betere prestaties en lagere rekencosten vergeleken met bestaande methoden.

Oorspronkelijke auteurs: Tao Feng, Haozhen Zhang, Zijie Lei, Peixuan Han, Jiaxuan You

Gepubliceerd 2026-04-28

📖 4 min leestijd☕ Koffiepauze-leesvoer

CC BY 4.0

Oorspronkelijke auteurs: Tao Feng, Haozhen Zhang, Zijie Lei, Peixuan Han, Jiaxuan You

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je voor dat je een grote, complexe opdracht hebt, zoals het bouwen van een huis of het oplossen van een ingewikkelde puzzel. Je hebt een hele verzameling vakmensen (de verschillende AI-modellen of "LLMs") tot je beschikking. Sommigen zijn snel maar niet zo slim, anderen zijn briljant maar duur en traag, en weer anderen zijn gespecialiseerd in specifieke taken zoals tekenen of rekenen.

De oude manier om dit te doen, was als een postbode die elke brief (vraag) in één keer naar één willekeurige vakman stuurde. Als die vakman de brief niet goed kon lezen, was het mis. Of je stuurde de brief naar dezelfde persoon, die het dan stap voor stap probeerde op te lossen, wat vaak veel tijd en geld kostte.

GraphPlanner is de nieuwe, slimme hoofdplanner die dit allemaal op een betere manier regelt. Hier is hoe het werkt, vertaald in alledaagse termen:

1. De Slimme Hoofdplanner (De Router)

In plaats van één persoon te kiezen, fungeert GraphPlanner als een regisseur die voor elke vraag een specifiek team samenstelt.

De Planner: Deze agent breekt de grote vraag op in kleinere, hanteerbare stukjes.
De Uitvoerder: Deze agent doet het zware werk voor elk stukje.
De Samenvatter: Deze agent pakt alle losse stukjes weer bij elkaar en maakt er één helder antwoord van.

GraphPlanner kiest niet alleen wie er aan het werk gaat, maar ook welk type vakman (het AI-model) het beste past bij dat specifieke stukje werk.

2. Het Gedachtenboek (Het Heterogene Grafisch Geheugen)

Dit is het meest unieke onderdeel. Stel je voor dat GraphPlanner een groot, levendig dagboek heeft dat hij bijhoudt.

In dit dagboek staat niet alleen wat er gebeurd is, maar ook wie wat heeft gedaan, hoe het is gelukt, en wat het heeft gekost.
Het systeem gebruikt een netwerk van verbindingen (een grafiek) om te onthouden: "Ah, voor dit soort rekenvragen werkt de snelle, goedkope vakman het beste, maar voor dit soort codeerproblemen hebben we de dure, slimme expert nodig."
Door dit dagboek te raadplegen, kan GraphPlanner leren van zijn eerdere fouten en successen, net als een mens die uit ervaring leert.

3. Het Spel van Beslissingen (Reinforcement Learning)

GraphPlanner leert door te spelen, net als iemand die een nieuw bordspel leert.

Het maakt een beslissing (bijvoorbeeld: "Ik stuur deze vraag naar de reken-expert").
Het kijkt naar het resultaat: Was het antwoord goed? Was het snel genoeg? Was het niet te duur?
Als het goed ging, krijgt het een puntje. Als het fout ging of te duur was, krijgt het een strafje.
Na veel oefeningen (training) wordt het zo goed in het maken van de juiste keuzes dat het een perfecte balans vindt tussen kwaliteit en kosten. Het leert precies wanneer het goedkoop is om iemand te sturen en wanneer het nodig is om de "topexpert" in te huren.

Wat zegt de paper over de resultaten?

De auteurs hebben GraphPlanner getest op 14 verschillende soorten taken, van wiskunde en programmeren tot algemene kennis. Hier zijn de belangrijkste bevindingen, zonder de resultaten te overdrijven:

Beter en goedkoper: GraphPlanner was tot 9,3% nauwkeuriger dan de beste bestaande methoden, terwijl het tegelijkertijd de kosten voor computerkracht (GPU) drastisch verlaagde. Ze noemen een voorbeeld waarbij de kosten daalden van 186 GiB naar slechts 1,04 GiB. Dat is alsof je van een dure vrachtwagen naar een kleine fiets verandert, maar toch dezelfde vracht bezorgt.
Slimme generalisatie: Het systeem werkt ook goed op vragen en AI-modellen die het nooit eerder heeft gezien. Het kan zijn kennis dus toepassen op nieuwe situaties zonder dat het opnieuw getraind hoeft te worden.
Twee manieren van werken:
- Snelle manier: Het maakt een beslissing op basis van wat het nu ziet (goedkoop en snel).
- Diepe manier: Het kijkt ook diep in zijn geheugen naar vergelijkbare oude situaties om de allerbeste beslissing te nemen (iets duurder, maar vaak nauwkeuriger).

Kortom: GraphPlanner is een slimme regisseur die leert van zijn verleden om voor elke vraag het perfecte team samen te stellen, waardoor je betere antwoorden krijgt voor minder geld en tijd.

Titel: GraphPlanner: Graph Memory-Augmented Agentic Routing for Multi-Agent LLMs

Auteurs: Tao Feng, Haozhen Zhang, Zijie Lei, Peixuan Han, Jiaxuan You (Universiteit van Illinois Urbana-Champaign)
Publicatie: ICLR 2026

1. Het Probleem

Bestaande methoden voor het routeren van Large Language Models (LLM's) zijn voornamelijk beperkt tot statische of vereenvoudigde scenario's. Ze vallen in twee categorieën:

Single-round routers: Deze maken één enkele toewijzing van een query naar een model op basis van embeddings of classificatie. Ze missen de capaciteit voor meervoudig redeneren, taakdecompositie of coördinatie tussen verschillende modellen.
Multi-round routers: Deze maken sequentiële keuzes op basis van context, maar behandelen elke oproep vaak als een onafhankelijke gebeurtenis zonder expliciete modellering van samenwerking tussen agenten. Dit leidt tot redundante oproepen, contextconflicten en een gebrek aan benutting van de complementaire sterke punten van verschillende modellen.

De opkomst van agentic LLM-systemen (waarbij modellen samenwerken in rollen zoals Planner, Executor en Samenvatter) creëert een nieuwe uitdaging: hoe kunnen we routers ontwerpen die niet alleen het juiste model kiezen, maar ook het juiste agente rol en de workflowstructuur dynamisch bepalen voor complexe, real-world taken? Bestaande routers kunnen de complexe, heterogene relaties tussen queries, antwoorden en modellen in deze dynamische omgeving niet effectief modelleren of gebruikmaken van historische ervaringen.

2. Methodologie: GraphPlanner

GraphPlanner is een heterogeen graf-gebaseerde router die routing vormt als een Multi-Agent Coördinatieprobleem binnen een Markov Beslissingsproces (MDP). Het systeem genereert voor elke query een dynamische workflow.

A. Formulering als MDP

State ( $S_t$ ): De huidige query die moet worden opgelost, verrijkt met context uit de workflow- en historische geheugengrafieken.
Action ( $A_t$ ): Een paar $(\alpha_t, m_t)$ $(α_{t}, m_{t})$ waarbij $\alpha_t$ $α_{t}$ de agentrol is (Planner, Executor, of Samenvatter) en $m_t$ $m_{t}$ het te gebruiken LLM-backbone is.
- Planner: Decomposeert complexe queries in sub-queries.
- Executor: Lost sub-queries op of genereert antwoorden.
- Samenvatter: Condenseert meerdere outputs tot een coherent antwoord.
Transitie: De omgeving update de workflow-geheugenstructuur op basis van de gekozen actie en het gegenereerde antwoord.
Reward ( $R_t$ ): Een balans tussen taakprestatie (bijv. nauwkeurigheid) en computatiekosten (GPU-tokens). De router wordt getraind om de totale verwachte return te maximaliseren.

B. Heterogeen Graf-Geheugen (GARNet)

Het kerninnovatiepunt is GARNet (Graph Memory-Augmented Routing Network), een heterogene graf die twee soorten geheugen integreert:

Workflow Memory Graph ( $G_{workflow}$ ): Modelleert de huidige interacties binnen de lopende taak (huidige query, gegenereerde antwoorden, gekozen rollen).
Historical Memory Graph ( $G_{history}$ ): Bevat aggregaties van eerdere succesvolle workflows, foutpatronen en efficiënte arbeidsverdelingen uit het verleden.

Architectuur:

De graf bevat knooppunten voor Queries, Responses en LLM-Rol Hub-nodes (gedeeld tussen workflow en geschiedenis).
Door gedeelde "role hub nodes" (bijv. een knooppunt voor "Planner-LLaMA3") te gebruiken, kan het systeem informatie uit het verleden direct koppelen aan de huidige beslissing zonder redundante knooppunten te creëren.
Message Passing: Een heterogene Graph Neural Network (GNN) verspreidt informatie door de graf, waardoor de router contextbewuste beslissingen kan nemen die zowel lokale workflow-dynamiek als globale historische patronen meenemen.

C. Training

Het beleid (policy) wordt geoptimaliseerd met Proximal Policy Optimization (PPO), een Reinforcement Learning (RL) algoritme. Dit stelt de router in staat om lange-termijn beloningen te leren (bijv. het vermijden van redundante stappen) in plaats van alleen op korte-termijn feedback te reageren.

3. Belangrijkste Bijdragen

Agentic Routing Framework: GraphPlanner is de eerste router die routing uitbreidt naar een volledig agentic setting, waarbij zowel de keuze van het LLM-model als de agentrol (Planner/Executor/Summarizer) gelijktijdig wordt geoptimaliseerd.
Heterogeen Graf-Geheugen: Het introduceert GARNet, een mechanisme om historische interacties en workflow-dynamiek te modelleren in een enkele, rijke state-representatie, wat inductieve en transductieve inferentie mogelijk maakt.
Efficiëntie en Kosten: Door RL en graf-gebaseerde planning, reduceert het systeem de GPU-kosten drastisch terwijl de nauwkeurigheid stijgt.
Generalisatie: Het systeem toont sterke zero-shot generalisatie naar onbekende taken en onbekende LLM-backbones zonder extra fine-tuning.

4. Resultaten

GraphPlanner werd geëvalueerd over 14 diverse taken in 6 domeinen (wiskunde, code, redenering, wereldkennis, etc.) en vergeleken met state-of-the-art single- en multi-round routers.

Prestatieverbetering:
- In Fase 1 (optimalisatie binnen bestaande workflows) verbeterde GraphPlanner de gemiddelde nauwkeurigheid met +3,8%.
- In Fase 2 (generatie van optimale workflows) verbeterde het de nauwkeurigheid met +9,3% ten opzichte van de beste baseline.
- Op onzichtbare taken (zero-shot) bereikte het een gemiddelde nauwkeurigheid van 78%, wat 20-40% hoger is dan eerdere routers.
Kostenreductie:
- De GPU-kosten werden drastisch verlaagd van 186,26 GiB (bij baselines zoals Router-R1) naar slechts 1,04 GiB voor GraphPlanner.
- Het systeem bevindt zich consequent op de Pareto-grens, wat betekent dat het voor een gegeven kostenplaatje de beste nauwkeurigheid biedt, of voor een gegeven nauwkeurigheid de laagste kosten.
Generalisatie:
- Het systeem presteert robuust op onbekende LLM-modellen (zoals Mistral-Nemo en Mixtral) die niet in de training zijn gebruikt.
- Het ondersteunt zowel inductieve (lichtgewicht, geen historische data nodig tijdens inferentie) als transductieve (gebruik van historische data voor hogere prestaties) inferentie.

5. Significantie

GraphPlanner markeert een verschuiving in het veld van LLM-routing van statische modelselectie naar dynamische workflow-generatie. Door het modelleren van routing als een coördinatieprobleem tussen heterogene agenten en het gebruik van graf-gebaseerd geheugen, lost het de beperkingen op van bestaande systemen die geen rekening houden met samenwerking of lange-termijn planning.

De paper bewijst dat het combineren van Reinforcement Learning met heterogene graf-structuren leidt tot systemen die niet alleen nauwkeuriger zijn, maar ook aanzienlijk efficiënter en schaalbaarder. Dit opent de deur voor toekomstige systemen die complexe, real-world taken kunnen oplossen door automatisch de juiste combinatie van modellen en agentrollen te selecteren, wat essentieel is voor de volgende generatie autonome AI-systemen. De code is open-source beschikbaar gesteld.