Technische Samenvatting: Arbor – Boomzoekopdracht als Cognitielaag voor Autonome Agenten

Probleemstelling

Recente vooruitgang in LLM-gebaseerde code-optimalisatie heeft aangetoond dat autonome agenten hoogwaardige oplossingen kunnen ontdekken voor geïsoleerde computationele targets (bijv. specifieke kernels of operatoren). Echter, de prestaties van productiesoftware vloeien voort uit de complexe interactie tussen meerdere lagen (applicatie, framework, compiler, kernel, hardware). Het optimaliseren van één laag kan bottlenecks of regressies in een andere laag blootleggen, wat resulteert in een stateful, grote actieruimte waar interventies eerdere vooruitgang ongeldig kunnen maken.

Bestaande benaderingen kampen met drie primaire beperkingen:

1. Geïsoleerde reikwijdte: Compiler autotuners en multi-agent frameworks opereren doorgaans binnen een enkele laag of op een enkel target, waardoor ze falen in het adresseren van cross-layer afhankelijkheden.
2. Gebrek aan Stateful Geheugen: Huidige systemen onderhouden geen gedeeld werkgeheugen dat evolueert met elke meting; zij behandelen fouten louter als stopsignalen in plaats van als diagnostische data.
3. Onvermogen om Cascaderende Fouten te Afhandelen: Wanneer een optimalisatie een systeemcrash of regressie veroorzaakt, missen bestaande systemen het mechanisme om de grondoorzaak te diagnosticeren, beperkingen terug te koppelen naar de zoekopdracht en de daaropvolgende exploratie vorm te geven.

De kernuitdaging verschuift van kandidaat-generatie naar kandidaat-selectie: het navigeren door een dynamisch landschap waar elke interventie de distributie van de bottleneck hervormt, wat een systeem vereist dat verschuivingen kan detecteren, fouten over verschillende lagen kan diagnosticeren en de zoekfrontier autonoom kan uitbreiden.

Methodologie: Het Arbor-framework

Arbor formuleert full-stack prestatieoptimalisatie als een heuristisch gescoord boomzoekproces over een dynamisch expanderende actieruimte. Het introduceert een cognitielaag die een expliciete zoekboom onderhoudt die dient als gedeeld werkgeheugen voor de agenten.

1. Zoekprocedure en Statusbeheer

• Boomstructuur: De optimalisatiestatus is een boom $T = (V, E)$ geworteld bij een geprofileerde baseline. Elk knooppunt vertegenwoordigt een actie en de uitkomst ervan (behouden, teruggedraaid of gecrasht). Het pad van de wortel naar het knooppunt definieert de cumulatieve sequentie van interventies.
• Dynamische Expansie: De boom is niet statisch. Na een succesvolle actie re-profileert het systeem om voorheen onzichtbare bottlenecks te onthullen, waardoor nieuwe takken ontstaan die bij de initialisatie nog niet bestonden.
• Zoeklus: De Orchestrator voert een depth-first loop uit:
  1. Profileer de huidige status om bottlenecks en GPU-tijddelen te identificeren.
  2. Score kandidaat-acties met behulp van een heuristische functie.
  3. Stuur de hoogst gescoorde actie door naar een Domain Specialist.
  4. Controleer resultaten via nauwkeurigheidsverificatie en end-to-end benchmarking.
  5. Update de boom: behouden acties worden de nieuwe baseline; teruggedraaide acties registreren diagnostische annotaties; gecrashte acties triggeren een grondoorzaakanalyse (RCA).
  6. Re-score resterende kandidaten naarmate de bottleneck-distributie verschuift.

2. Heuristische Scoring

Kandidaten worden gescoord door verwacht gewin af te wegen tegen kosten en risico, inclusief een exploratiebonus:
$$h(a) = \frac{g(a)}{c(a) \cdot (1 - r_{acc}) \cdot (1 - r_{crash}) \cdot m_{gap}} + C_s \frac{\ln N}{1 + n_{cat}}$$

• $g(a)$: Verwacht gewin, geschat op basis van het GPU-tijddeel van de doelkernel en categorie-specifieke snelheidswinst-priors (afgeleid van een persistente kennisbank).
• $c(a)$: Geschatte wandklok-kosten (implementatie, herstart, benchmarking).
• $r_{acc}, r_{crash}$: Empirische foutpercentages voor nauwkeurigheid en crashes, verfijnd naarmate de campagne vordert.
• $m_{gap}$: Urgentiemultiplier die schaalt met de resterende kloof tot de throughput-target.
• UCB-term: Stimuleert exploratie van ondergesamplede actiecategorieën.

3. Multi-Agent Architectuur met Checks en Balances

Arbor structureert zijn agenten om effectieve engineeringorganisaties na te bootsen, waarbij capaciteiten worden gedecomposeerd in Hard Skills (domeinexpertise) en Soft Skills (coördinatieprotocollen).

• De Orchestrator (De "Tech Lead"):

  • Stuurt de optimalisatieloop aan door middel van profiling, scoring en delegatie.
  • Construeert dynamisch Domain Specialists tijdens runtime voor specifieke taken (kernel, framework, communicatie, compiler, dispatch).
  • Stelt prompts samen met behulp van hardwarecontext, kennisbank-entries en foutgeschiedenissen.
  • Implementeert zelf geen code, maar beslist wat er geprobeerd wordt en wie het implementeert.

• De Critic (De "Quality Assurance"):

  • Waarborgt stabiliteit en de integriteit van metingen.
  • Voert Root-Cause Analysis (RCA) uit op crashes, waarbij onderscheid wordt gemaakt tussen implementatiefouten en onproductieve richtingen.
  • Handhaaft Guardrails om benchmark-anomalieën te detecteren.
  • Voert Introspectie uit om te evalueren of een teruggedraaid idee waarde behoudt onder andere beperkingen.
  • Monitort de systeemgezondheid op lange termijn en publiceert beperkingen om het herbezoeken van onproductieve regio's te voorkomen.

• Domain Specialists:

  • Worden dynamisch geconstrueerd per taak.
  • Opereren asynchroon over verschillende lagen en voeren iteratieve verfijning uit met lokale validatie voordat ze merge-klare patches teruggeven.
  • Houden zich aan de beperkingen die door de Critic zijn gepubliceerd.

• Persistente Kennisbank:

  • Cumuleert strategieën en foutmodi over sessies heen.
  • Maakt warm-start transfer mogelijk naar nieuwe modellen en hardware, wat de scoring-priors informeert en de variantie tussen runs vermindert.

Belangrijkste Bijdragen

1. Stateful Boomzoekopdracht Formulering: Het artikel formuleert cross-layer optimalisatie als een boomzoekopdracht waarbij de boom dient als gedeeld werkgeheugen. Fouten propageren als beperkingen op kind-nodes, en successen triggeren re-profiling om de zoekfrontier uit te breiden.
2. Checks-and-Balances Multi-Agent Architectuur: Introduceert een dual-agent systeem waarbij een Orchestrator agressieve optimalisatie aandrijft terwijl een Critic de stabiliteit bewaakt. Geen van beide agenten kan het systeem eenzijdig aansturen, wat garandeert dat offers in korte-termijn throughput alleen worden gedaan wanneer dit noodzakelijk is voor de levensvatbaarheid van de sessie.
3. Skill Decompositie: Decomponeert agent-capaciteiten in hard skills (domeinexpertise) en soft skills (coördinatieprotocollen), ondersteund door een persistente kennisbank voor cross-sessie transfer.
4. Dynamische Specialist Constructie: Beweegt weg van vaste agenten door Domain Specialists dynamisch tijdens runtime te construeren op basis van het specifieke optimalisatie-target, de hardwarecontext en historische data.

Resultaten

Arbor werd geëvalueerd op LLM-inference serving over zes productiemodellen op AMD Instinct GPU's (MI355X en MI300X).

• Throughput Verbeteringen:
  • Op MI355X bereikte Arbor een throughput-verbetering van +40% tot +193% ten opzichte van vendor-geoptimaliseerde baselines na dagen van volledig autonome operatie.
  • Op MI300X (cross-generation validatie) varieerden de verbeteringen van +62% tot +99%.
• Reproduceerbaarheid: De variantie tussen runs was binnen 2 procentpunten, wat een hardware-agnostische reproduceerbaarheid aantoont.
• Ablatie/Vergelijking: Een enkele agent zonder de Arbor-harnas (waarbij het "harnas" het multi-agent boomzoekframework is) stagneerde op slechts +33% throughput verbetering en crashte onherstelbaar binnen enkele uren.
• Case Study (gpt-oss-120b): In een specifieke zoekboom voor een 120B MoE-model verkende het systeem 30 acties. 9 werden behouden, 16 werden teruggedraaid met diagnostische inzichten, en 3 crashten maar werden hersteld via RCA. Het systeem bereikte 6.515 tok/s/GPU (een verbetering van 48% ten opzichte van de 4.405 tok/s/GPU baseline), gebruikmakend van inzichten uit introspectie (bijv. het identificeren van dode code-paden) en RCA (het classificeren van crashes als dependency-issues in plaats van algoritmische gebreken).

Betekenis en Claims

Het artikel claimt dat Arbor een verschuiving vertegenwoordigt van geïsoleerde kandidaat-generatie naar het navigeren door stateful, grote actieruimtes. Door fouten te behandelen als diagnostische signalen die de exploratie hervormen en een gedeeld werkgeheugen te behouden, maakt Arbor volledig autonome campagnes van meerdere dagen mogelijk die anders onmogelijk zouden zijn vanwege systeeminstabiliteit.

Het framework toont aan dat:

1. Cross-layer optimalisatie haalbaar is zonder menselijke tussenkomst, mits het systeem in staat is om verschuivingen in bottlenecks te detecteren en fouten over de stack heen te diagnosticeren.
2. Checks-and-balances architecturen cruciaal zijn voor duurzame autonomie, om te voorkomen dat agressieve exploratie het systeem destabiliseert.
3. Kennisoverdracht over sessies en hardwaregeneraties heen haalbaar is via persistent geheugen, wat de drempel verlaagt voor het in gebruik nemen van nieuwe hardware of modellen.

Uiteindelijk streeft Arbor ernaar de operationele kosten en de koolstofintensiteit van LLM-deployments te verlagen door de gecoördineerde inspanning te automatiseren die traditioneel vereist is van engineeringteams over de volledige software- en hardwarestack.