💬 NLP

FutureWeaver: Planning Test-Time Compute for Multi-Agent Systems with Modularized Collaboration

FutureWeaver is een framework dat de prestaties van multi-agent-systemen onder vaste testtijd-rekenbudgetten verbetert door zelfgeïnduceerde samenwerkingsmodules en een tweelags planningarchitectuur te introduceren om inferentietrajecten te optimaliseren via principiële resourceallocatie.

Oorspronkelijke auteurs: Dongwon Jung, Peng Shi, Muhao Chen, Yi Zhang

Gepubliceerd 2026-06-03

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Dongwon Jung, Peng Shi, Muhao Chen, Yi Zhang

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 de manager bent van een team van gespecialiseerde experts (zoals een onderzoeker, een programmeur, een schrijver en een factchecker) die probeert een zeer moeilijke puzzel op te lossen. Je hebt een strikte limiet aan hoeveel geld je kunt uitgeven aan hun tijd en inspanning (je "budget").

In het verleden, als je wilde dat je team beter presteerde, kon je simpelweg zeggen: "denk harder na" of "probeer het opnieuw." Maar in een multi-agent systeem helpt het niet altijd om simpelweg één persoon harder te laten werken. Soms moet de onderzoeker met de programmeur praten, of de factchecker het concept van de schrijver beoordelen voordat je verder gaat. Het probleem is: Hoe beslis je wie met wie praat, wanneer, en hoe lang, zonder je budget te overschrijden?

Dit is het probleem dat het paper FUTUREWEAVER probeert op te lossen. Hier is hoe het werkt, onderverdeeld in eenvoudige concepten:

1. Het Probleem: De "Starre Assemblagelijn"

De meeste huidige systemen werken als een starre assemblagelijn. Eén persoon voert een taak uit, geeft deze door aan de volgende, enzovoort. Als de eerste persoon een fout maakt, kan de hele lijn falen, of verspil je geld door dezelfde stap keer op keer te herhalen.

Het Probleem: Deze systemen weten niet hoe ze hun teamleden effectief kunnen combineren. Ze hebben ook moeite met het plannen vooruit. Ze kunnen al al hun geld uitgeven aan de eerste stap van een puzzel, waardoor er niets meer overblijft voor de cruciale laatste stappen.

2. De Oplossing: "Collaboratie-modules" (De kant-en-klare recepten)

FUTUREWEAVER introduceert een nieuw idee genaamd Collaboration Modules.

De Analogie: Stel je voor dat je in plaats van alleen een lijst met individuele chefs, een bibliotheek hebt van kant-en-klare recepten.
- Recept A: "De onderzoeker en de schrijver werken samen om een verhaal te schrijven."
- Recept B: "Drie programmeurs schrijven parallel code, en een reviewer kiest de beste versie uit."
Hoe het werkt: Het systeem roept niet alleen één agent aan; het kan een heel "recept" (een module) aanroepen dat automatisch meerdere agents tegelijk coördineert. Deze recepten zijn niet door mensen handmatig geschreven; het systeem leert ze door naar zichzelf te kijken terwijl het succes boekt. Het speelt het spel vele malen, ziet welke teamverbanden het beste werkten, en zet die succesvolle patronen om in herbruikbare "recepten".

3. De Hersenen: "Dual-Level Planning" (De GPS en de Verkenner)

Zelfs met geweldige recepten moet je nog steeds weten welke je op welk moment moet kiezen. FUTUREWEIVER gebruikt een tweeledig planningsysteem, vergelijkbaar met een GPS gecombineerd met een verkenner:

Korte-termijn Planning (De Verkenner): Deze kijkt naar de directe volgende stap. "Als ik nu het 'Onderzoeker + Schrijver'-recept gebruik, is dat dan een goed idee op basis van wat we net hebben gedaan?" Het controleert of het team het eens is over de zet en of het in soortgelijke situaties in het verleden goed heeft gewerkt.
Lange-termijn Planning (De GPS): Dit is het magische deel. Het voert het werk nog niet echt uit; het stelt zich de toekomst voor. Het vraagt: "Als ik nu dit recept kies, kom ik dan zonder geld te zitten voordat ik de puzzel heb voltooid?" Het simuleert de rest van de reis in zijn hoofd (zonder echt geld uit te geven) om te zien of het pad haalbaar is.
Het Resultaat: Het systeem kiest de zet die niet alleen nu goed is, maar ook garandeert dat het niet zonder budget komt te zitten voordat de klus geklaard is.

4. De "Self-Play" (Leren door te doen)

Hoe weet het systeem welke recepten goed zijn of hoeveel ze kosten? Het gebruikt Self-Play Reflection.

De Analogie: Denk aan een schaker die duizenden partijen tegen zichzelf speelt om de beste strategieën te leren.
Hoe het werkt: Voordat het systeem echte problemen oplost, doorloopt het vele oefenopdrachten. Het legt vast hoeveel elk "recept" kostte en hoe vaak het tot een overwinning leidde. Vervolgens gebruikt het deze gegevens om zijn bibliotheek van recepten en zijn kostenramingen op te bouen. Het is als een coach die wedstrijdbeelden analyseert om een tactisch plan op te stellen.

5. De Resultaten: Meer waar voor je geld

Het paper testte dit systeem op drie moeilijke uitdagingen:

Algemene kennis & Web Browsing: Antwoorden vinden op het internet.
Diepgaand Onderzoek: Graven door veel documenten om specifieke feiten te vinden.
Coderen: Computerprogramma's schrijven en controleren.

Wat gebeurde er?

Oude methoden verspilden vaak geld. Ze gaven te veel uit aan de vroege stappen of kwamen vast te zitten in lussen, waardoor ze geen budget meer overhielden voor het uiteindelijke antwoord.
FUTUREWEAVER behaalde consequent betere antwoorden binnen het budget. Het leerde om geld agressief uit te geven wanneer het ertoe deed (zoals bij het controleren van code) en conservatief wanneer dat niet nodig was.

Samenvatting

FUTUREWEAVER is als een slimme projectmanager voor een team van AI-agents. In plaats van simpelweg te zeggen dat ze "harder moeten werken", doet het het volgende:

Creëert herbruikbare teamwork-recepten op basis van wat in het verleden heeft gewerkt.
Plant twee stappen vooruit (en verder) om te garanderen dat het niet zonder geld komt te zitten voordat de klus is geklaard.
Leert van zijn eigen oefenrondes om beter te worden in het managen van het team.

Het resultaat is een systeem dat moeilijkere problemen oplost met hetzelfde bedrag aan geld, simpelweg door slimmer te zijn in hoe het zijn team inzet.

Technische Samenvatting: FUTUREWEAVER

Probleemstelling

Hoewel het schalen van test-time computation effectief is gebleken voor het verbeteren van de prestaties van Large Language Models (LLM's) in single-agent settings (bijv. via zelfcorrectie, iteratieve verificatie of Best-of-N sampling), brengt het uitbreiden van deze technieken naar multi-agent systemen unieke uitdagingen met zich mee. Bestaande benaderingen vertrouwen vaak op rigide orchestrator-worker paradigma's die agents sequentieel uitvoeren, waardoor de synergie tussen heterogene agents niet wordt benut. Bovormatig ontbreken huidige methoden principiële mechanismen voor het toewijzen van compute onder strikte budgetrestricties. Ze optimaliseren vaak binnen vaste inferentie-structuren of falen om inferentie te behandelen als een trajectplanning-probleem over een combinatorische ruimte van agent-invocaties. Gevolgen hiervan zijn dat systemen mogelijk te veel investeren in laag-rendabele vroege stappen of te weinig investeren in cruciale latere coördinatiestappen, wat leidt tot suboptimale prestaties, zelfs wanneer er voldoende budget beschikbaar is.

Methodologie: FUTUREWEAVER

Het paper stelt FUTUREWEAVER voor, een framework dat is ontworpen om de allocatie van test-time compute in multi-agent systemen te optimaliseren onder vaste budgetten. Het framework integreert drie kerncomponenten:

1. Collaboratie-modules

Om verder te gaan dan sequentiële, één-agent-tegelijk uitvoering, introduceren de auteurs collaboratie-modules. Dit zijn modulaire, aanroepbare functies die hoogwaardige coördinatiestrategieën tussen meerdere agents inkapselen (bijv. "zoeken en dan browsen" of "ensemble reasoning").

Abstractie: Modules worden geformaliseerd als $m = (S, \kappa)$ , waarbij $S$ een subset is van worker agents en $\kappa$ een coördinatiestrategie is.
Ontdekking: Modules worden niet handmatig ontworpen, maar zijn automatisch geïnduceerd via Self-Play Reflection. Het systeem voert trajecten uit op validatietaken, identificeert terugkerende interactiepatronen die leiden tot succes, en abstraheert deze tot herbruikbare modules.
Actieruimte: De actieruimte van de orchestrator wordt uitgebreid om zowel individuele base agents als deze collaboratie-modules te bevatten ( $A' = A \cup M$ ).

2. Dual-Level Planning Architectuur

Om door de combinatorische ruimte van agent/module-invocaties te navigeren onder een hard budget, maakt FUTUREWEAVER gebruik van een dual-level planningstrategie geïnspireerd door A*-zoekalgoritmen en speculative decoding:

Short-Horizon Planning (Lokale Winst): Evalueert de directe belofte van een kandidaat-actie $\alpha_t$ . Het berekent een winstscore $g(\alpha_t)$ gebaseerd op:
- Self-Consistency (SC): Meet de lokale consensus onder gesamplede acties om vertrouwen te peilen.
- Performance Prior (PP): Een empirische betrouwbaarheidsscore afgeleid van de succespercentages van vergelijkbare historische trajecten gevonden in de experience buffer.
- De winst wordt berekend als het geometrisch gemiddelde: $g(\alpha_t) = \sqrt{SC(\alpha_t) \cdot PP(\alpha_t)}$ .
Long-Horizon Planning (Globale Haalbaarheid): Voert abstracte lookahead uit om te schatten of een kandidaat-actie binnen het resterende budget tot een succesvol traject kan leiden.
- De orchestrator genereert speculatieve trajecten symbolisch (zonder agents uit te voeren) die potentiële toekomstige sequenties van modules vertegenwoordigen.
- Met behulp van kostenramingen afgeleid uit self-play worden trajecten die het resterende budget overschrijden weggefilterd.
- Een haalbaarheidsscore $h(\alpha_t)$ wordt berekend op basis van de proportie kandidaat-acties die budget-conforme continuaties toelaten.
- Deze score stuurt de short-horizon planner actief aan, zodat lokale beslissingen in lijn zijn met de globale haalbaarheid.
Selectie: De uiteindelijke utility is $f(\alpha_t) = g(\alpha_t) + h(\alpha_t)$ . De actie met de hoogste utility wordt geselecteerd, waarbij een balans wordt gevonden tussen onmiddellijke progressie en langetermijn-budgetcompliance.

3. Self-Play Reflection

Dit offline, iteratieve proces dient als de motor van het framework:

Het genereert executietrajecten op een subset van validatietaken om een experience buffer op te bouwen.
Het levert kostenramingen (gemiddeld over geobserveerde subtaken) en prestatieschattingen (succespercentages op trajectniveau) voor zowel base agents als ontdekte modules.
Het drijft de ontdekking van collaboratie-modules aan door succesvolle trajecten te analyseren op terugkerende patronen.

Experimentele Resultaten

De auteurs hebben FUTUREWEAVER geëvalueerd op drie benchmarks: GAIA (algemene AI-assistent taken), BrowseComp-Plus (webbrowsen) en BigCodeBench (coderen). Ze vergeleken het met vaste workflows (ADAS, AFlow), standaard ReAct met test-time scaling (Best-of-N, Iterative Verification), en ReAct met collaboratie-modules (Budget-Unaware/Aware).

Prestaties: FUTUREWEAVER presteerde consistent beter dan alle baselines in diverse budgetsettings op alle drie de benchmarks. Zo behaalde het op GAIA met Claude-modellen een nauwkeurigheid van 48,15% bij een budget van 0,5, vergeleken met 38,27% voor de beste ReAct-variant.
Budgetbenutting: In tegenstelling tot baselines die vaak beschikbare budgetten onderbenutten (waarbij de totale kosten ruim onder de restrictie blijven steken), maakte FUTUREWEAVER het budget agressief en effectief gebruik, waarbij compute-resources direct werden vertaald in prestatiewinst.
Componentanalyse: Ablatiestudies toonden aan dat hoewel short-term planning alleen al een boost bood, en long-term planning alleen iets beter presteerde bij hogere budgetten, de duale combinatie de sterkste resultaten opleverde, wat de noodzaak bevestigt van het integreren van lokale en globale signalen.

Betekenis en Claims

Het paper claimt dat FUTUREWEAVER een kritiek gat in multi-agent systemen opvult: het gebrek aan principiële mechanismen voor budget-geconstreineerde compute-allocatie en effectieve collaboratie.

Kernbijdrage: Het werk formuleert multi-agent optimalisatie als een trajectplanning-probleem over een combinatorische ruimte van agent- en module-invocaties, in plaats van een simpel hulpbronallocatie-probleem.
Innovatie: Door coördinatie te behandelen als een function-calling probleem met automatisch geïnduceerde modules en door een dual-level planner te gebruiken die lookahead koppelt aan kandidaat-generatie, stelt het framework systemen in staat om dynamisch te beslissen wanneer en hoe ze complexe collaboraties aanroepen.
Resultaat: De resultaten laten zien dat gestructureerde collaboratie en vooruitziende planning essentieel zijn om vaste compute-budgetten om te zetten in effectieve multi-agent prestaties, wat een veelbelovende richting biedt voor het bouwen van meer adaptieve en compute-efficiënte systemen.

De auteurs blijven bescheiden over toekomstige implicaties en richten zich strikt op de validatie van de effectiviteit van hun framework voor inferentie-tijd optimalisatie van multi-agent collaboratie onder strikte restricties.