💻 computer science

Multi-Agent LLM Collaborative Reasoning and Task Planning for Complex Task Solving

Dit artikel stelt een multi-agent LLM-framework voor met afzonderlijke rollen voor planner, executor en verifier die opereren op een afhankelijkheidsbewuste taakgrafiek met gekalibreerde parameters en gedeelde geheugenmechanismen, wat single-agent baselines bij het oplossen van complexe taken aanzienlijk overtreft door de voltooiingspercentages, nauwkeurigheid en feitelijke consistentie te verbeteren terwijl fouten in tools worden verminderd.

Oorspronkelijke auteurs: Wentao Zhang, Tian Liao, Yihui Feng

Gepubliceerd 2026-07-06

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Wentao Zhang, Tian Liao, Yihui Feng

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (https://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 probeert een enorme, ingewikkelde puzzel op te lossen, zoals het bouwen van een wolkenkrabber van LEGO terwijl je geblinddoekt bent en alleen kunt vertrouwen op het geheugen en de instructies van één persoon. Dat is in essentie wat er gebeurt wanneer we één enkel Large Language Model (LLM) vragen om een complex probleem op te lossen. Het probeert alles tegelijk te doen: de structuur plannen, de muren bouwen, de afmetingen controleren en fouten herstellen. Vaak raakt het in de war, maakt het een fout in een vroeg stadium, en bouwt het de rest van de toren op basis van die fout op, wat leidt tot een instorting.

Dit paper stelt een betere manier voor: in plaats van één persoon die alles doet, creëren we een gespecialiseerde bouwploeg bestaande uit drie verschillende AI-agenten die samenwerken in een strikte, georganiseerde lijn.

Zo werkt hun "bouwploeg", met behulp van eenvoudige analogieën:

1. De Drie Rollen (De Ploeg)

Het paper splitst het werk op in drie specifieke taken, net als bij een echt projectteam:

De Planner (De Architect): Deze agent kijkt naar het grote plaatje. In plaats van alleen te zeggen "bouw een toren", breekt het de taak af in een kaart van afhankelijkheden. Het zegt: "Eerst hebben we een fundering nodig. Dan hebben we pilaren nodig. We kunnen het dak er pas op zetten als de pilaren klaar zijn." Het wijst een "prioriteitsscore" toe aan elke stap op basis van hoe belangrijk deze is en hoe risicovol.
De Uitvoerder (De Bouwer): Deze agent doet het eigenlijke zware werk. Het volgt de kaart van de Architect, pakt de benodigde gereedschappen (zoals een rekenmachine, een zoekmachine of een code-interpreter) en bouwt de specifieke onderdelen. De Bouwer maakt zich geen zorgen over het hele gebouw; het richt zich alleen op het correct voltooien van de specifieke taak.
De Verifieerder (De Inspecteur): Dit is de nieuwe, cruciale toevoeging. Voordat het werk van de Bouwer wordt geaccepteerd, controleert de Inspecteur het. Ze kijken naar het bewijs: "Heb je het juiste gereedschap gebruikt? Klopt de wiskunde? Komt dit overeen met de blauwdruk?" Als de Inspecteur niet genoeg vertrouwen heeft (onder een specifieke "vertrouwensscore" van 0,72), stuurt hij de Bouwer terug om dat specifieke deel te herstellen. Ze breken niet het hele gebouw af; ze repareren alleen de kapotte steen.

2. Het Gedeelde Notitieblok (Gedeeld Geheugen)

In een normaal gesprek kunnen mensen vergeten wat er vijf minuten geleden is gezegd. In dit systeem delen alle drie de agenten een digitaal notitieblok.

Wanneer de Architect een plan tekent, gaat dit in het notitieblok.
Wanneer de Bouwer een stuk bewijsmateriaal vindt, wordt dit genoteerd met een "bron-tag".
Wanneer de Inspecteur een idee afwijst, wordt die afwijzing ook vastgelegd, zodat niemand diezelfde gebroken gedachte opnieuw probeert te gebruiken.
Dit zorgt ervoor dat als het team een sectie opnieuw moet starten, ze niet alles vanaf nul opnieuw hoeven te leren. Ze kunnen gewoon in de aantekeningen kijken.

3. Het "Verkeerslicht"-Systeem (Het Protocol)

Om te voorkomen dat de agenten door elkaar heen praten of vastlopen in een eindeloze discussie, volgen ze een strikte set regels:

Groen Licht: De Architect geeft een taak.
Geel Licht: De Bouwer voert het werk uit en toont het bewijs.
Rood of Groen Licht: De Inspecteur controleert het werk.
- Groen: "Goed zo." Het werk wordt opgeslagen.
- Rood: "Stop." De Inspecteur legt precies uit waarom het is mislukt (bijv. "Verkeerd gereedschap gebruikt" of "Ontbrekende data"). De Architect past vervolgens het plan aan om alleen dat specifieke probleem op te lossen.

4. De Resultaten: Waarom het beter werkt

De onderzoekers hebben deze "Ploeg" getest tegenover een enkele "Solo Werker" (een standaard GPT-4 model) bij moeilijke taken zoals complexe wiskunde, het gebruik van meerdere tools en het beantwoorden van lastige feitelijke vragen.

Beschouw de Solo Werker als een briljante maar vermoeide student die probeert in één ruk een essay van 10 pagina's te schrijven. Ze kunnen een kleine fout maken in paragraaf 2, en tegen de tijd dat ze bij paragraaf 10 zijn, is het hele essay ontspoord.

De "Ploeg"-aanpak werkt als een team van redacteurs en schrijvers die elkaars werk controleren terwijl ze bezig zijn. Het paper vond dat door dit systeem te gebruiken:

Ze voltooiden meer taken: Het succespercentage steeg met 27,3%.
Ze kregen vaker de juiste antwoorden: De nauwkeurigheid verbeterde met 19,6%.
Ze maakten minder fouten met tools: Fouten zoals het gebruiken van de verkeerde rekenmachine of het zoeken naar het verkeerde ding daalden met 31,5%.
Ze waren eerlijker: Ze waren minder geneigd om feiten te verzinnen, wat de feitelijke consistentie met 24,8% verbeterde.

De Kernboodschap

Het paper betoogt dat het geheim voor het oplossen van moeilijke problemen niet alleen het "slimmer" maken van de AI is. Het is organisatie. Door de rollen van plannen, uitvoeren en controleren te scheiden, en hen te dwingen te communiceren via een gestructureerd, op bewijs gebaseerd systeem, vermijdt het AI-team de "één-persoons-bias" waarbij één enkele fout het hele project ruïneert. Het verandert een chaotische brainstormsessie in een gedisciplineerd, controleerbaar constructieproject.

Technische Samenvatting: Multi-Agent LLM Collaboratieve Redenering en Taakplanning voor Complexe Taakoplossing

1. Probleemstelling

Complexe taken in open domeinen vereisen dat grote taalmodellen (LLM's) langdurige redeneringen uitvoeren, gecontroleerde decompositie toepassen en betrouwbare, door tools gemedieerde uitvoering leveren. Hoewel single-agent LLM-workflows zijn geavanceerd door technieken zoals Chain-of-Thought en ReAct, lijden ze aan drie primaire beperkingen:

Eenzijdig planningsbias: Een enkel model heeft de neiging een dominant perspectief te volgen, wat leidt tot vroege foutieve aannames die stilzwijgend voortplanten.
Geaccumuleerde fouten: Lange redeneerketens accumuleren fouten die moeilijk te corrigeren zijn zonder een volledige herstart.
Zwakke toolcontrole: Single agents hebben vaak moeite met de precieze sequencing, parametervariatie en validatie van externe tool-invocaties.

Bestaande multi-agent benaderingen (bijv. Generative Agents, Multiagent Debate, AutoGen) vertrouwen vaak op onbeperkte conversatie, wat kan leiden tot redundante dialoog en ongecontroleerde expansie zonder gegarandeerde betrouwbaarheid. Dit artikel adresseert de behoefte aan een controleerbaar, controleerbaar en op bewijs gebaseerd multi-agent framework dat planning, uitvoering en verificatie scheidt.

2. Methodologie

Het voorgestelde framework introduceert een Planner-Executor-Verifier collaboratieve architectuur die wordt beheerd door een hiërarchische taakgrafiek en een geordend interactieprotocol.

A. Framework Architectuur

Het systeem scheidt contextbegrip van agent-collaboratie. Het maakt gebruik van een CNN-versterkte context-extractor om gestructureerde en visuele taaksignalen (tabellen, diagrammen, logs) naast natuurlijke taal te modelleren, en fuseert deze representaties voordat de taakplanning plaatsvindt.

De kernlus omvat drie gespecialiseerde agents die een episodisch geheugen delen:

Planner Agent: Zet input-queries om in een afhankelijkheidsbewuste taakgrafiek ( $G_T = (V, E, \chi)$ ). Het wijst prioriteiten toe op basis van afhankelijkheidscentraliteit, relevantie voor de gebruikersdoelstelling, onzekerheid en middelenkosten.
Executor Agent: Voert geplande subtaken uit, roept tools aan, genereert artefacten en produceert lokale antwoorden met compacte bewijssporen.
Verifier Agent: Evalueert claims tegenover bewijsmateriaal, detecteert tegenstrijdigheden en geeft reparatieverzoeken af als de betrouwbaarheid onder een gekalibreerde drempelwaarde valt.

B. Hiërarchische Taakplanning

Taken worden gerepresenteerd als gerichte grafieken waarbij knopen subtaken zijn met status-tuples: $(prioriteit, betrouwbaarheid, middelenbudget, status)$.
De planningsprioriteit ( $p_i$ ) voor een subtaak wordt berekend als:
$p_i = \alpha d_i + \beta u_i + \gamma(1 - c_i) - \lambda r_i$
Waar:

$d_i$ : Afhankelijkheidscentraliteit
$u_i$ : Relevantie voor de gebruikersdoelstelling
$c_i$ : Huidige betrouwbaarheid
$r_i$ : Geschatte executiekosten
$\alpha, \beta, \gamma, \lambda$ : Coëfficiënten bepaald via grid search op een validatieset.

Standaardparameters: $\alpha = 0.35, \beta = 0.30, \gamma = 0.25, \lambda = 0.10$ .

C. Interactieprotocol en Geheugen

Het systeem handhaaft een getypeerd interactieprotocol om controleerbaarheid te garanderen:

Planner geeft een subtaak uit met vereisten en terminatiecriteria.
Executor retourneert een claim met een bewijsspoor.
Verifier geeft een Accept, Revise, of Split signaal uit.

Gedeeld Geheugen: Updates worden beheerd via een functie $\phi(\cdot)$ die getypte records (positief/negatief bewijs, conflicten) opslaat met semantische en grafische indexering. Dit stelt het systeem in staat om geverifieerde informatie te hergebruiken en te voorkomen dat hele antwoorden opnieuw gegenereerd moeten worden wanneer slechts specifieke knopen falen.

Foutbewuste Reparatie: Wanneer de verifier een claim afwijst, identificeert het systeem de specifieke foutmodus (ontbrekend bewijs, verkeerde tool, etc.) en opent het alleen de betreffende knoop en de bijbehorende downstream-afhankelijkheden opnieuw, in plaats van de gehele taak te herstarten.

D. Tool Fout Taxonomie

Het artikel definieert een verenigde taxonomie voor tool-fouten om vergelijkbare metrieken te waarborgen:

Verkeerde toolselectie
Ongeldige parameters
Ongeldige invocatiesequentie
Executiefout
Inconsistente resultaatintegratie

3. Belangrijkste Bijdragen

End-to-End Collaboratieve Architectuur: Een multi-agent systeem dat taakdecompositie, rol-specifieke uitvoering, kruisvalidatie en gerichte reparatie integreert voor complexe open-domein taken.
Hiërarchisch Planningsalgoritme: Een geformaliseerde planningsmethode met expliciete parametervelese regels en sensitiviteitsanalyse voor prioriteitscoëfficiënten en verifier-drempelwaarden.
Concreet Gedeeld Geheugen Mechanisme: Een gedefinieerde updatefunctie die informatieopslag, indexering, retrieval en conflictafhandeling specificeert met behulp van getypte records.
Verenigde Tool-Fout Classificatie: Een gestandaardiseerde taxonomie voor het tellen van tool-gebruiksfouten, wat een eerlijke vergelijking tussen methoden mogelijk maakt.
Empirische Validatie: Vergelijkende experimenten die consistente verbeteringen laten zien ten opzichte van een single-agent GPT-4 baseline op het gebied van logisch redeneren, tool-orkestratie en open-domein probleemoplossing.

4. Experimentele Resultaten

Het framework werd geëvalueerd op drie benchmarkcategorieën: Multi-step logisch redeneren, Cross-tool orkestratie en Open-domein probleemoplossing. De baseline was een single-agent GPT-4 instantie die dezelfde tools en instructies gebruikte.

Prestatieverbeteringen (Relatief aan Baseline):

Taakvoltooiingspercentage: +27,3% (Baseline: 63,0% $\to$ Voorgesteld: 80,2%)
Antwoordnauwkeurigheid: +19,6% (Baseline: 68,4% $\to$ Voorgesteld: 81,8%)
Redeneernauwkeurigheid: +22,1%
Feitelijke Consistentie: +24,8%
Tool Foutpercentage: -31,5% (Baseline: 25,7% $\to$ Voorgesteld: 17,6%)

Sensitiviteit en Ablatie:

Parametersensitiviteit: Het variëren van prioriteitscoëfficiënten ( $\pm 0.10$ ) veranderde de voltooiingspercentages met niet meer dan 2,6 procentpunten. Het variëren van de verifier-drempelwaarde ( $\theta$ ) van 0,65 naar 0,80 veranderde de nauwkeurigheid met niet meer dan 3,2 procentpunten, wat duidt op robuustheid.
Ablatiestudie: Het verwijderen van de Verifier veroorzaakte de grootste daling in feitelijke consistentie (-11,6%). Het verwijderen van Hierarchical Planning verminderde de voltooiingspercentages en verhoogde redundante beurten. Het verwijderen van het Ordered Protocol leidde tot instabiele samenwerking en langere, minder effectieve dialogen.

5. Betekenis en Claims

Het artikel beweert dat het voorgestelde framework de beperkingen van single-path redeneren aanpakt door redeneren te behandelen als een controleerbaar proces in plaats van een single-pass generatiegebeurtenis.

Controleerbare Collaboratie: Door expliciete rollen toe te wijzen en een getypeerd protocol af te dwingen, voorkomt het systeem de "ongecontroleerde dialoogexpansie" die gebruikelijk is bij onbeperkte multi-agent debatten. Elke agent-bericht dient een specifieke functie (planning, actie of verificatie).
Foutmitigatie: De scheiding van verantwoordelijkheden maakt het mogelijk om fouten (bijv. ongeldige tool-sequenties) te detecteren en te repareren voordat ze zich voortplanten naar het uiteindelijke antwoord, wat de tool-foutpercentages aanzienlijk vermindert.
Interpreteerbaarheid: De architectuur zorgt ervoor dat uiteindelijke antwoorden kunnen worden teruggevoerd naar geaccepteerde subtaken en bewijsrecords, wat de controleerbaarheid van het redeneerproces vergroot.
Schaalbaarheid: Het framework is ontworpen voor taken met een lange horizon waarbij vroege fouten anders stilzwijgend de uiteindelijke output zouden degraderen, waarbij een stabiele afweging wordt geboden tussen betrouwbaarheid en interactiekosten (gemiddeld ~8,6 beurten).

De auteurs concluderen dat gestructureerde communicatie en rolseparatie belangrijker zijn voor prestaties dan simpelweg het verhogen van het aantal agents of het volume van de dialoog. Toekomstig werk wordt geïdentificeerd als het onderzoeken van adaptieve parametertuning en de implementatie in real-world workflows met heterogene tools.