Technische Samenvatting: Stateful ReAct-agenten voor Token-efficiënte Autonome Experimentatie

Probleemstelling

Het "autoresearch"-patroon maakt autonome experimentatie mogelijk door een Large Language Model (LLM) iteratief code te laten aanpassen om een doelmetriek te optimaliseren. Hoewel effectief, is de standaardimplementatie stateless: bij elke iteratie moet de agent de volledige experimentele context opnieuw reconstrueren door de volledige geschiedenis van resultaten en codemodificaties die zijn geaccumuleerd in een onderzoeksrichtbestand (bijv. program.md) opnieuw te lezen.

Dit ontwerp leidt tot een structurele inefficiëntie:

• Tokenkosten: De promptgrootte groeit lineair ($O(n)$) met het aantal iteraties, wat leidt tot een totale tokencost van $O(n^2)$.
• Redundantie: De agent verzendt informatie die hij in eerdere stappen al heeft verwerkt opnieuw.
• Schaalbaarheid: Naarmate experimenten zich ophopen, nadert de prompt de limieten van het contextvenster, wat afkorting of samenvatting noodzakelijk maakt, wat het risico loopt op het verlies van kritieke experimentele nuances.

Het paper stelt dat omdat LLM's geen transiënte staat kunnen behouden over interacties heen (Huang et al. [10]), extern staatbeheer een architecturale noodzaak is om deze kwadratische kostencurve te doorbreken.

Methodologie

De auteurs herformuleren het autoresearch-patroon als een stateful ReAct-agent met behulp van LangGraph. In plaats van monolithische prompts die de volledige geschiedenis bevatten, interageert de agent met het ML-systeem via tool calls, terwijl de experimentele geschiedenis, redeneersporen en convergentiemetrieken worden bewaard in een getypeerde persistente staat-grafiek.

Architectuur

De agent werkt als een staat-grafiek met drie primaire nodes:

1. REASON: Roept het LLM (Claude Haiku 4.5) aan met de huidige staat-context. Het model genereert redeneersporen en tool calls.
2. TOOLS: Voert tool calls deterministisch uit (bijv. experimenten draaien, resultaten opvragen) en geeft observaties terug.
3. CHECK: Evalueert convergentiecriteria (doelmetriek drempelwaarde, iteratiebudget, of LLM-conclusie) zonder LLM-betrokkenheid.

Conditionele randen sturen de flow: als het LLM tool calls produceert, gaat de controle naar TOOLS; anders gaat het naar CHECK. Indien niet geconvergeerd, keert de loop terug naar REASON.

Staatbeheer

De kerninnovatie is de AgentState (een getypeerde dictionary) die persisteert over iteraties heen. Deze bevat:

• messages: Een sliding window van de laatste 20 berichten om de inputkosten te beperken.
• experiment_history: Een lijst van alle eerdere resultaten.
• current_best: Het beste resultaat dat tot nu toe is gevonden.
• train_py_content: De huidige codestatus.

Cruciaal is dat de agent een helper class (ExperimentState of CodeState) gebruikt om bij elke stap een compacte samenvatting te genereren. Deze samenvatting bevat:

• Huidig iteratieaantal en beste geaggregeerde metrieken.
• De laatste 5 experimenten (of recente resultaten).
• Strategienotities en mislukte benaderingen.

Dit zorgt ervoor dat het LLM bij elke stap slechts $O(1)$ input tokens ontvangt, ongeacht het totaal aantal uitgevoerde experimenten. De volledige geschiedenis blijft toegankelijk in de staat, maar wordt uitgesloten van de prompt tenzij expliciet via tools wordt opgevraagd.

Tooling

De agent interageert met het ML-systeem via specifieke tools:

• Hyperparameter Tuning: get_experiment_history en run_experiment.
• Code Optimalisatie: get_current_train_py, modify_train_py (met guardrails om evaluatielogica te behouden), submit_training_job, en query_results.

Belangrijkste Bijdragen

1. Architecturale Herformulering: Het transformeren van het stateless autoresearch-patroon naar een stateful ReAct-agent met behulp van LangGraph, waarbij het werkgeheugen van de agent wordt ontkoppeld van zijn prompt-context.
2. Token Efficiëntie: Het demonstreren van een structurele reductie in tokencost van $O(n^2)$ (stateless) naar $O(n)$ (stateful) totale kosten, met een $O(1)$ per-iteratie kost.
3. Implementatie Blauwdruk: Het bieden van een gedetailleerde, reproduceerbare architectuur (inclusief staat-schema's, grafieklogica en tool-definities) voor practitioners om stateful agenten te implementeren.

Experimentele Resultaten

De auteurs evalueerden de stateful agent tegenover een stateless baseline op twee benchmarktaken met 3 willekeurige seeds.

Taak 1: Hyperparameter Tuning (Kleine Observaties)

• Setup: 15 iteraties optimaliseren van XGBoost op de UCI Covertype dataset. Observaties waren klein (~200 tokens: JSON config + metrieken).
• Resultaten:
  • Token Reductie: De stateful agent verbruikte 90% minder tokens (2.492 vs. 24.465), een 9,8× reductie.
  • Prestaties: Beide agenten behaalden vergelijkbare F1-scores (0,779 vs. 0,764), waarbij verschillen werden toegeschreven aan seed-variantie in plaats van architecturale superioriteit.
  • Kostencurve: De stateless inputkosten groeiden lineair van ~700 naar ~1.900 tokens per iteratie; de stateful kosten bleven vlak op ~100 tokens.

Taak 2: Code Prestatie Optimalisatie (Grote Observaties)

• Setup: 40 iteraties optimaliseren van een Python data-verwerkingsfunctie. Observaties waren groot (~1.500–3.000 tokens: volledige broncode + benchmarks).
• Resultaten:
  • Token Reductie: De stateful agent verbruikte 52% minder tokens (627K vs. 1.275K), een 2,0× reductie.
  • Prestaties: Beide agenten behaalden vergelijkbare versnellingen (~1,9× over baseline).
  • Kostencurve: Hoewel de stateful agent nog steeds een vaste kost met zich meebracht door de "huidige beste code" te verzenden (~1.500 tokens) bij elke stap, vlakt de totale kostencurve af. In contrast hiermee bleven de stateless kosten lineair stijgen, met een accumulatie van over 80.000 tokens aan geschiedenis bij iteratie 40.

Vergelijkende Analyse

De token reductieratio is omgekeerd evenredig aan de grootte van de observatie ten opzichte van de staat-samenvatting.

• Kleine Observaties: De samenvatting met vaste grootte is dramatisch kleiner dan de geaccumuleerde geschiedenis, wat een hoge reductieratio oplevert (9,8×).
• Grote Observaties: De stateful agent moet nog steeds het huidige code-artefact verzenden, wat de ratio beperkt (2,0×). Het paper merkt echter op dat naarmate de iteraties toenemen (bijv. naar 100 of 200), de $O(n^2)$ vs. $O(n)$ divergentie de ratio aanzienlijk zal doen verbreden (geprojecteerd 4× tot 7×).

Betekenis en Claims

Het paper claimt dat de primaire bijdrage structurele efficiëntie is, niet noodzakelijkerwijs verbeterde optimalisatiekwaliteit. De stateful agent bereikt een vergelijkbare optimalisatiekwaliteit als de stateless baseline, terwijl hij het tokenverbruik drastisch vermindert.

• Schaalbaarheid: De $O(1)$ per-iteratie kost maakt arbitrair lange experiment-sequenties mogelijk zonder prompt-afkorting of verlies van beslissingscapaciteit.
• Economische Impact: Hoewel de besparingen bescheiden zijn voor korte runs, worden ze materieel voor grootschalig onderzoek (honderden experimenten dagelijks), waarbij de kwadratische kosten van stateless executie een dominante bottleneck worden.
• Toekomstperspectief: De auteurs suggereren dat naarmate de experimentele horizonten langer worden, de kwadratische tokencost van stateless executie de primaire beperking zal worden, waardoor stateful architecturen essentieel worden voor duurzame autonome experimentatie.

De auteurs blijven bescheiden over de optimalisatiekwaliteit en stellen expliciet dat de geobserveerde verschillen in metrieken binnen de ruis vallen en niet geïnterpreteerd moeten worden als een kwalitatief voordeel van de stateful aanpak. De focus blijft strikt op de efficiëntiewinsten van de architecturale verschuiving.