🤖 AI

Retrieval-Conditioned Topology Selection with Provable Budget Conservation for Multi-Agent Code Generation

Dit artikel introduceert Retrieval-Guided Adaptive Orchestration (RGAO), een multi-agent framework dat dynamisch codegeneratietopologieën selecteert op basis van structurele complexiteit die is ontleend aan een hiërarchische code-index, en aldus bewezen begrotingsbesparing bereikt door de innovatieve integratie van op complexiteit gebaseerde routing en formele resource-algebra's.

Oorspronkelijke auteurs: Abhijit Talluri, Pujith Anne, Bhagavan Choudary Pendiyala, Raghavendra Chilukuri

Gepubliceerd 2026-05-08

📖 4 min leestijd☕ Koffiepauze-leesvoer

CC BY 4.0

Oorspronkelijke auteurs: Abhijit Talluri, Pujith Anne, Bhagavan Choudary Pendiyala, Raghavendra Chilukuri

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 zeer bekwame, maar zeer dure AI-assistenten. Je doel is om bugs te fixen of nieuwe code te schrijven voor een enorm softwareproject.

Het probleem met huidige AI-teams is dat ze geen idee hebben van de omvang van de klus.

Als je hen vraagt een typefout in één bestand te fixen, sturen ze misschien het hele "Speciale Interventie Team" met een kraan, een bulldozer en een sloopploeg. Dit is een verspilling van tijd en geld.
Als je hen vraagt het elektriciteitsnet van een hele stad te herbouwen (een complexe wijziging over veel bestanden), sturen ze misschien gewoon één persoon met een schroevendraaier. Dit leidt tot falen.

Dit artikel introduceert een nieuw systeem genaamd CODE-AGENT met een speciale manager genaamd RGAO. Hier is hoe het werkt, met eenvoudige analogieën:

1. De "Verkenners" voor de "Ploeg" (Retrievel-Guided Routing)

In oude systemen keek de manager alleen naar de woorden die je typte om te beslissen wie er gestuurd moest worden. Als je zei "fix de login", gingen ze ervan uit dat het een grote klus was.

RGAO verandert het spel. Voordat ze iemand sturen, sturen ze een Verkenners om naar de daadwerkelijke code te kijken.

De Verkenners beklimt de code-structuur (zoals een boom) en meet dingen zoals: "Hoe diep zijn de wortels?" "Hoeveel takken zijn verstrikt?" "Hoeveel verschillende gebouwen heeft dit effect op?"
Op basis van deze structurele kaart kiest de manager het juiste team:
- FASTPATH: Een kleine typefout? Stuur één persoon om het direct te fixen.
- SUBAGENT: Een kleine functie? Stuur één specialist.
- MULTIAGENT: Een grote wijziging? Stuur een pijplijn van experts die samenwerken.
- DEEPRESEARCH: Een verwarrende, vage vraag? Stuur een team om eerst zwaar onderzoek te doen.

Het Resultaat: Het artikel beweert dat deze "Verkenners"-methode het aantal verkeerde teamtoewijzingen heeft verlaagd van 30% naar 8%. Het is alsof een generaal eerst naar een kaart kijkt voordat hij beslist of hij een sluipschutter of een leger stuurt.

2. Het "Onbreekbare Budget" (Bewijsbaar Budgetbehoud)

AI-agenten zijn duur; ze verbruiken "tokens" (zoals brandstof) en tijd. Als een agent in een lus blijft hangen of gek wordt, kan het je hele budget in seconden opbranden.

De auteurs hebben een Wiskundig Veiligheidsnet gecreëerd.

Denk aan de hoofdmanger als een ouder met een toeslag van $100.
Als de ouder een kind (een sub-agent) stuurt om een taak te doen, geven ze het kind een strikte toeslag (bijvoorbeeld $10).
Het systeem heeft een wiskundig bewijs (Stelling 1) dat zegt: "Ongeacht hoeveel kinderen je stuurt, of hoe vaak ze het opnieuw proberen, het totale geld dat door de hele familie wordt uitgegeven zal nooit de oorspronkelijke $100 van de ouder overschrijden."

Waarom dit speciaal is: De meeste systemen controleren het budget terwijl het werk gebeurt (en als ze op zijn, is het te laat). Dit systeem controleert de wiskunde voordat iemand begint te werken. Als het plan eruitziet alsof het $110 zal kosten, zegt het systeem "Nee, annuleer dit plan" voordat er ook maar één dollar is uitgegeven.

3. De "Assemblagelijn" (Architectuur)

Het systeem werkt in lagen:

De Verkenners: Leest de code-boom en meet complexiteit.
De Dispatcher: Gebruikt de metingen om de juiste teamgrootte te kiezen.
De Boekhouder: Controleert de wiskunde om ervoor te zorgen dat het team niet te veel uitgeeft.
De Werknemers: De daadwerkelijke AI-agenten doen de codering, wisselen efficiënt notities uit zonder over iedereen heen te schreeuwen (wat tijd bespaart).

De Conclusie

Het artikel beweert dat deze combinatie—eerst kijken naar de code-structuur en wiskundig garanderen dat je niet te veel uitgeeft—een systeem creëert dat veel slimmer is over wie er gestuurd moet worden en hoeveel het zal kosten.

Belangrijke Opmerking uit het Artikel:
De auteurs zijn eerlijk over de beperkingen. Ze hebben dit getest op een "proxy" (een simulatie) omdat het uitvoeren van volledige realiteitstests nu te duur en riskant is. Ze geven ook toe dat als de code in een taal staat die hun "Verkenners" niet goed kent (zoals Rust, wat ze nog steeds leren), het systeem niet helemaal zo scherp is. Maar voor de tests die ze hebben uitgevoerd, werkte het aanzienlijk beter dan de oude "gok op basis van trefwoorden"-methoden.

Technische Samenvatting: Topologiekeuze op Basis van Retrieval met Bewijsbaar Behoud van Budget voor Multi-Agent Codegeneratie

Probleemstelling

Multi-agent Large Language Model (LLM)-systemen voor codegeneratie staan voor een fundamenteel routeringsprobleem: het bepalen van de optimale orkestratietopologie (bijvoorbeeld monolithisch, single-specialist, pipeline/swarm of retrieval-gewicht) op basis van de structurele complexiteit van de code die wordt gewijzigd. Bestaande systemen kiezen topologieën doorgaans op basis van oppervlakkige querykenmerken (bijvoorbeeld regex-classificators) of taakafhankelijkheidsgrafieken zonder de daadwerkelijke structuur van de codebase te raadplegen. Dit leidt tot "verkeerde routing", waarbij eenvoudige bewerkingen door complexe pipelines worden geleid of omgekeerd, wat onnodige efficiëntiestraffen met zich meebrengt. Bovendien, hoewel formele resource-algebra's bestaan om agentbudgetten te beheren, ontbreekt er vaak integratie met dynamische topologiekeuze, en worden resourcegaranties frequent pas tijdens runtime afgedwongen in plaats van statisch.

Methodologie: CODE-AGENT en RGAO

Het artikel introduceert CODE-AGENT, een multi-agent raamwerk dat draait om Retrieval-Guided Adaptive Orchestration (RGAO). Het systeem werkt via een gesloten lus waarbij retrievalsignalen direct orkestratiebeslissingen informeren, gekoppeld aan een formele budgetalgebra die resourcebehoud garandeert.

1. Hiërarchische Code-Search & Complexiteitsextractie

Voordat er gerouteerd wordt, voert het systeem een retrieval-pas uit over een hiërarchische boomindex van de code-repository (Root $\to$ Directory $\to$ File $\to$ Symbol).

Retrieval-strategie: Queries worden geclassificeerd in vijf typen (identifier, exact, conceptueel, afhankelijkheid, structureel). Conceptuele queries triggeren een multi-path fusiestrategie die LATTICE (path-score kalibratie), KohakuRAG (multi-query herformulering) en PageIndex (LLM-geleide beam search) combineert, gefuseerd via Reciprocal Rank Fusion (RRF).
Complexiteitsvector ( $c$ ): Uit het opgehaalde subgraaf extrahert RGAO een vijfdimensionale structurele complexiteitsvector in sub-milliseconden:
$c = (d_{dep}, n_f, n_s, h_t, \rho_x)$
Waarbij $d_{dep}$ de maximale afhankelijkheidsdiepte is, $n_f$ het aantal bestanden, $n_s$ het aantal symbolen, $h_t$ de boomdiepte en $\rho_x$ de cross-module koppelingsratio.

2. Retrieval-Guided Adaptive Orchestration (RGAO)

De topologierouter is een deterministische drempelclassificator die de complexiteitsvector $c$ en de gebruikersquery afbeeldt op een van de vier topologieën:

FASTPATH: Monolithische uitvoering voor triviale, single-file bewerkingen.
SUBAGENT: Single specialist-contract voor gemiddelde reikwijdte ( $n_f \le 3$ ).
MULTIAGENT: Lineaire pipeline of parallelle swarm voor complexe, multi-file taken ( $n_f > 3$ ).
DEEPRESEARCH: Multi-stage, retrieval-gewicht uitvoering voor ambiguïteit bevattende queries.

3. Formele Budgetalgebra & Statische Verificatie

Sub-agenten worden beheerd door formele contracten $\langle I, C, T, M \rangle$ , waarbij $C$ een zeshoekige budgetvector bevat (iteraties, calls, tokens, seconden, retries, handoffs).

Budgetbehoudstheorema (Theorema 1): Het artikel bewijst dat onder specifieke aannames (deterministische toolkosten, begrenste retrieval-diepte, eindige actieruimte) het totale resourceverbruik van een delegatiebos begrensd is door het root-budget.
Statische Verificatie: Een VERIFYCONSERVATION-algoritme controleert de budgetalgebra in $O(|V| + |E|)$ tijd voordat er een LLM-call wordt gedaan. Het zorgt ervoor dat de som van de kind-budgetten plus directe kosten het budget van de ouder niet overschrijdt, waardoor resource-overschrijdingen statisch en niet reactief worden voorkomen.

4. Uitvoeringslaag

Het systeem maakt gebruik van een SwarmSupervisor om een Directed Acyclic Graph (DAG) van taken te bouwen. Het handhaaft een drie-poort pre-executie-protocol (contractbestaan, budgethaalbaarheid, handoff-integriteit) en maakt gebruik van getypeerde SwarmArtifact-objecten voor inter-agent communicatie, wat de coördinatie-overhead verlaagt van $O(n^2)$ naar $O(k)$ .

Belangrijkste Bijdragen

Complexiteits-geconditioneerde Topologierouter: Een router die retrieval-afgeleide code-structuursignalen afbeeldt op orkestratiebeslissingen, wat de verkeerde routing-rates significant verlaagt in vergelijking met regex-gebaseerde baselines.
Bewijsbaar Budgetbehoud: Een structuur-inductietheorema (Theorema 1) dat garandeert dat hiërarchische contractdelegatie nooit de grenzen van de ouder overschrijdt, statisch geverifieerd in lineaire tijd ten opzichte van de DAG-grootte.
Hiërarchische Retrieval-engine: Een innovatieve combinatie van LATTICE, KohakuRAG en RepoGraph-stijl afhankelijkheidsuitbreiding over een boomgestructureerde index, specifiek gebruikt als routeringsignaal.
Systeemcompositie: De integratie van retrieval-geconditioneerde routing met statische budgetverificatie, een eigenschap die geen van beide componenten alleen toestaat.

Empirische Resultaten

De evaluatie werd uitgevoerd met een proxy-harness (evals/swebench_proxy.py) om gesandboxe interacties te abstraheren, waarbij volledige SWE-bench runs werden uitgesteld naar een volgende pass vanwege vervuilingsproblemen en resourcebeperkingen.

Routing-nauwkeurigheid: Op een gelabelde dataset van 250 instances verlaagde RGAO de verkeerde routing van 30,1% (regex-baseline) naar 8,2% (95% Wilson CI [6,1, 10,9]), een statistisch significant verbetering (gepaarde McNemar, $p < 10^{-6}$ ).
Performance-overhead:
- DAG-construktie: Sub-millisecond (< 0,01 ms).
- Boomindex opbouw (200 bestanden, 2.002 nodes): 11,1 ms.
- Instantiatie contract-fabriek: ~1,1 $\mu$ s.
- Budget-check overhead: ~0,65 $\mu$ s.
Pipeline-correctheid: Het systeem voltooide 100% van de vijf samengestelde multi-agent pipelines (inclusief interventie-herstelscenario's) met een gemiddelde tokenkost van ~6.000 tokens per pipeline.
Proxy-benchmarks: CODE-AGENT loste 40% van een synthetische SWE-bench-set op bij pass@1, wat efficiëntie aantoont in vergelijking met onbeperkte monolithische agenten (8–20x tokenreductie).

Betekenis en Claims

Het artikel claimt dat de primaire betekenis ligt in de compositie van twee eerder gescheiden onderzoekslijnen: complexiteits-geconditioneerde LLM-routing en formele resource-algebra's.

Noviteit: Noch complexiteits-geconditioneerde routing, noch formele budgetalgebra alleen, levert de eigenschap op van "bewijsbaar budgetbehoud onder retrieval-geconditioneerde dynamische topologiekeuze".
Veiligheid & Efficiëntie: Het statische verificatiemechanisme stelt het systeem in staat om onhaalbare configuraties voor uitvoering te verwerpen, waardoor de "blast radius" van agentfouten wordt begrensd en de kostenbarrière voor agentische codegeneratie in resource-beperkte omgevingen wordt verlaagd.
Interpreteerbaarheid: In tegenstelling tot geleerde routingbeleid, gebruikt de RGAO-router interpreteerbare, hand-geoptimaliseerde drempels op basis van structurele signalen, wat aansluit bij het op contracten gebaseerde veiligheidsverhaal.

De auteurs erkennen beperkingen, waaronder de afhankelijkheid van deterministische kostenveronderstellingen voor het strikte behoudstheorema (hoewel verwachte grenzen worden geboden voor stochastische kosten) en het huidige gebruik van hand-geoptimaliseerde drempels in plaats van een geleerde opvolger. Zij merken op dat het routing-voordeel smaller wordt onder distributieveranderingen (bijvoorbeeld onbekende talen) waarbij de tree-sitter grammatica de complexiteitsvector kan verslechteren.