EvoTool: Self-Evolving Tool-Use Policy Optimization in LLM Agents via Blame-Aware Mutation and Diversity-Aware Selection

EvoTool is een zelfevoluerend kader dat de tool-gebruikspolitiek van LLM-agenten optimaliseert via een gradiëntvrije evolutionaire aanpak met drie nieuwe mechanismen: blame-attributie op basis van trajecten, feedback-gestuurde gerichte mutatie en diversiteitsbewuste selectie, wat leidt tot significante prestatieverbeteringen op meerdere benchmarks.

De kern

Stel je voor dat je een zeer slimme, maar soms wat ongeduldige assistent hebt die een complexe taak voor je moet uitvoeren, zoals het boeken van een complete vakantie met vluchten, hotels en activiteiten. Deze assistent is een LLM-agent (een taalmodel) en hij heeft een gereedschapskist vol met digitale tools om zijn werk te doen.

Het probleem is: soms lukt het niet. De assistent kiest de verkeerde tool, gebruikt de verkeerde gegevens, of slaat een stap over. En als hij faalt, krijg je vaak pas aan het einde te horen: "Het is mislukt." Je weet niet waar het precies fout ging. Was het de planning? De keuze van de tool? Of de manier waarop hij de resultaten samenvatte?

Dit is waar EVOTOOL om de hoek komt kijken. Het is een slim systeem dat deze assistent zelf laat evolueren en verbeteren, zonder dat mensen handmatig elke regel code moeten herschrijven.

Hier is hoe het werkt, vertaald in alledaagse termen:

1. De Assistent in Vier Delen (De Module-Opdeling)

In plaats van de assistent als één grote, ondoorzichtige "zwarte doos" te zien, breekt EVOTOOL hem op in vier gespecialiseerde teamleden:

• De Planner: Bedenkt het stappenplan.
• De Selector: Kiest welk gereedschap (tool) nodig is.
• De Caller: Voert het gereedschap daadwerkelijk uit (typen, klikken, data ophalen).
• De Synthesizer: Vat alles samen en geeft het antwoord.

2. Het Grote Probleem: Wie is de Schuldige?

Stel, de assistent faalt bij het boeken van een hotel. Bij oude methoden werd vaak alles tegelijk aangepakt (alsof je de hele auto in elkaar slaat omdat de band lek is). Dat werkt niet goed; je lost misschien het bandprobleem op, maar breekt dan de motor.
Andere methoden keken alleen naar één ding (bijvoorbeeld alleen de planner), maar vergeten dat de fout misschien door de keuze van de tool werd veroorzaakt.

EVOTOOL doet iets slims: De Blame-Aware Mutation (De Schuld-toewijzing).
Het systeem kijkt naar de "traject" (het verhaal van wat er gebeurd is) en vraagt een slimme "rechter" (een ander AI-model): "Waar ging het precies fout?"

• Was het omdat de planner geen stappenplan had?
• Of omdat de selector de verkeerde API koos?
• Of omdat de caller de verkeerde parameters invulde?

De rechter wijst de specifieke schuldige aan.

3. De Chirurgische Operatie (Gerichte Mutatie)

Zodra de schuldige bekend is, doet EVOTOOL geen grootschalige renovatie. Het voert een chirurgische ingreep uit.
Stel, de Selector (de gereedschapskiezer) was de schuldige. Dan krijgt alleen die persoon een nieuwe instructie (een "feedback") gebaseerd op de fout die hij maakte. De Planner, Caller en Synthesizer blijven ongemoeid.
Het is alsof je een voetballer die vaak de bal verliest, een specifieke training geeft, terwijl je de doelman en de verdedigers laat rusten.

4. Een Divers Team Behouden (Diversiteits-Selectie)

In veel AI-systemen kiezen ze altijd de "beste" versie en gooien ze de rest weg. Dat is gevaarlijk, want misschien is versie A geweldig op korte afstand, maar versie B beter op lange afstand. Als je alleen versie A houdt, verlies je die flexibiliteit.
EVOTOOL houdt een divers team van verschillende versies van de assistent in stand. Het kiest niet alleen de "winnaar", maar zorgt dat er altijd verschillende specialiteiten in het team zitten. Zo voorkomt het dat het systeem "vastloopt" in één manier van denken.

Waarom is dit zo goed?

• Efficiëntie: Het verspillen geen tijd aan het herschrijven van dingen die al goed werken.
• Snelheid: Het leert sneller omdat het precies weet waar het moet knutselen.
• Resultaat: In tests (zoals het boeken van vluchten of het zoeken van informatie) wint EVOTOOL het van de beste bestaande methoden met een ruime marge (meer dan 5 punten), en dat geldt voor verschillende soorten AI-modellen.

Kortom:
EVOTOOL is als een slimme coach die niet roept: "Jullie zijn allemaal slecht, begin opnieuw!"
Maar die zegt: "Jij, de planner, je had een goed idee, maar jij, de selector, je koos de verkeerde tool. Hier is een tip voor jou. Jullie anderen, blijf doen wat je doet."
Zo evolueert het team stap voor stap naar perfectie, zonder dat iemand in de war raakt.

Technische samenvatting

Probleemstelling

LLM-agenten die externe tools gebruiken, zijn afhankelijk van effectieve beleidspolitieken (tool-use policies) om complexe taken op te lossen. Het optimaliseren van deze beleidslijnen is echter uitdagend vanwege twee hoofdproblemen:

1. Vertraging in supervisie: Feedback (succes of falen) is vaak pas beschikbaar aan het einde van een lange interactiecyclus (long-horizon trajectories).
2. Moeilijkheid van credit assignment: Wanneer een agent faalt, is het moeilijk om te bepalen welke specifieke stap of module (bijv. planning, tool-selectie, aanroep of synthese) de oorzaak was.

Bestaande aanpakken vallen vaak in twee uitersten:

• Monolithische optimalisatie: Hierbij wordt het hele agent-prompt als één blok geoptimaliseerd. Dit leidt tot verstrengeling van gedragingen; het repareren van één fout kan andere competenties destabiliseren.
• Single-aspect optimalisatie: Hierbij worden individuele componenten geïsoleerd geoptimaliseerd. Dit negeert echter de propagatie van fouten tussen modules in lange trajecten.

Er is een behoefte aan een methode die gerichte foutcorrectie mogelijk maakt zonder de stabiliteit van het totale systeem te verstoren.

Methodologie: EVOTOOL

EVOTOOL is een zelf-evoluerend framework dat een modulaire tool-use beleidsoptimalisatie uitvoert via een gradient-free evolutionair paradigma. In plaats van de gewichten van het LLM te wijzigen, evolueert het framework de module-specificaties (prompts en regels) van de agent.

De agent wordt opgedeeld in vier distincte modules:

1. Planner: Decomposeert de taak in subdoelen.
2. Selector: Beslist welke tool moet worden aangeroepen.
3. Caller: Construeert geldige argumenten en voert de tool uit.
4. Synthesizer: Integreert de tool-outputs in het definitieve antwoord.

Het framework gebruikt drie kernmechanismen in een iteratieve zelf-verbeteringslus:

1. Trajectory-Grounded Blame Attribution (Fouttoeschrijving)

Om het credit-assignment-probleem op te lossen, analyseert EVOTOOL het volledige interactietraject.

• Een "Blamer LLM" ontvangt het gedetailleerde logboek van de interactie (diagnostische traces) en de uiteindelijke uitkomst.
• Deze LLM wijst blame-scores toe aan elke van de vier modules (0 tot 1) om te bepalen welke module het meest verantwoordelijk is voor de fout.
• De module met de hoogste score wordt geselecteerd als het doelwit voor mutatie. Dit zorgt ervoor dat fouten lokaal worden gelokaliseerd in plaats van dat het hele systeem blindelings wordt aangepast.

2. Feedback-Guided Targeted Mutation (Gerichte Mutatie)

Zodra de schuldige module is geïdentificeerd, wordt deze specifiek aangepast.

• Een "Mutator LLM" genereert natuurtaalkundige feedback gebaseerd op het specifieke falende traject.
• Deze feedback bevat een diagnose van de fout en een concreet voorstel voor een lokale wijziging in de specificatie van die ene module.
• Alleen de geselecteerde module wordt bijgewerkt; de andere drie modules blijven onveranderd. Dit minimaliseert het risico op regressies in andere competenties.

3. Diversity-Aware Population Selection (Selectie met Diversiteitsbewustzijn)

Om te voorkomen dat de populatie van beleidsvarianten te snel convergeert naar een suboptimale strategie (premature convergence), wordt een diversiteitsbehoudsstrategie toegepast.

• In plaats van alleen de "beste" kandidaat op basis van een gemiddelde score te kiezen, behoudt EVOTOOL een populatie van varianten.
• Een kandidaat wordt behouden als hij op minstens één specifieke instantie (instance-level) de beste prestatie levert.
• Dit zorgt ervoor dat specialisten die goed zijn in specifieke soorten taken (complementaire vaardigheden) behouden blijven, wat essentieel is voor robuustheid in diverse taken.

Belangrijkste Bijdragen

1. EVOTOOL Framework: Een nieuw zelf-evoluerend systeem dat modulaire tool-use policies optimaliseert zonder gradienten, door het probleem op te splitsen in vier modules.
2. Nieuwe Mechanismen:
   • Trajectory-Grounded Blame Attribution: Lokaliseert fouten tot een specifieke module via diagnostische traces.
   • Feedback-Guided Targeted Mutation: Voert gerichte, interpreteerbare updates uit op basis van natuurlijke taalfeedback.
   • Diversity-Aware Population Selection: Behoudt complementaire kandidaten om mode-collapse te voorkomen.
3. Empirische Validatie: Uitgebreide evaluatie op vier benchmarks, waarbij het framework consistent beter presteert dan state-of-the-art baselines.

Resultaten

EVOTOOL werd getest op vier benchmarks: ToolBench, RestBench, τ-Bench (stateful, lange trajecten) en BFCL (functie-aanroepen). De experimenten werden uitgevoerd met twee achtergrondmodellen: GPT-4.1 en Qwen3-8B.

• Prestatieverbetering: EVOTOOL presteerde consistent beter dan sterke baselines (zoals ReAct, OPRO, PromptBreeder, AdaPlanner, DRAFT, enz.) met een marge van meer dan 5 punten in de algemene score.
  • Op GPT-4.1 bereikte het een overall score van 70.6 (tegenover ~63-64 voor de beste concurrenten).
  • Op Qwen3-8B bereikte het 57.0 (tegenover ~51-52 voor concurrenten).
• Robuustheid op Lange Trajecten: Op de moeilijke τ-Bench (lange, stateful interacties) presteerden single-aspect methoden slecht (omdat ze cross-module afhankelijkheden missen), terwijl EVOTOOL een score van 52.0 haalde, wat aantoont dat het de module-interacties effectief coördineert.
• Efficiëntie: EVOTOOL is token-efficiënter dan monolithische methoden. Omdat mutaties beperkt blijven tot één module en geen globale zoektocht vereisen, wordt de token-kost per verbetering aanzienlijk verlaagd.
• Transferabiliteit: Beleidslijnen die op het ene dataset of model zijn geëvolueerd, bleken goed te transfereren naar andere datasets en zelfs naar andere model-architecturen (bijv. van Qwen naar GPT), wat aangeeft dat het framework fundamentele tool-use vaardigheden leert in plaats van oppervlakkige patronen.

Significantie

EVOTOOL biedt een oplossing voor het fundamentele probleem van credit assignment in complexe agent-taken. Door de agent te ontleden in modulaire componenten en deze gericht te verbeteren op basis van gedetailleerde diagnostiek, overkomt het de beperkingen van zowel "grote zwarte doos" optimalisatie als geïsoleerde lokale fixes.

De studie toont aan dat gradient-free evolutionaire zoektocht, wanneer gekoppeld aan blame-aware targeting en diversiteitsbehoud, een krachtige en schaalbare route is om LLM-agenten zelfstandig te laten evolueren naar hogere prestaties zonder de noodzaak van grote datasets of het hertrainen van modelgewichten. Dit heeft grote implicaties voor de ontwikkeling van robuuste, autonome agenten in real-world omgevingen waar fouten complex en multi-causaal zijn.