SWE-AGILE: A Software Agent Framework for Efficiently Managing Dynamic Reasoning Context

Probleemstelling

Bestaande benaderingen voor autonome Software Engineering (SWE) agents, vaak gebaseerd op het ReAct-paradigma, kampen met een fundamenteel dilemma tussen redeneerdiepte en contextbeperkingen:

1. Gebrek aan System-2 Redenering: Traditionele methoden genereren vaak slechts "shallow" (oppervlakkige) gedachtegangen. Ze missen de expliciete, analytische System-2 redenering die nodig is voor complexe edge cases en diepgaande analyse.
2. Het Context-dilemma:
   • Als men de volledige redeneergeschiedenis (Chain-of-Thought of CoT) behoudt om de agent te helpen, leidt dit tot een contextexplosie. Bij multi-turn taken (veel interacties) groeit de context lineair, wat resulteert in het "Lost-in-the-Middle"-probleem (de aandacht van het model verdunt in lange sequenties) en hoge GPU-kosten.
   • Als men de geschiedenis verwijdert om contextruimte te besparen, moet de agent bij elke stap de volledige situatie redundant opnieuw analyseren, wat inefficiënt is en de redeneercontinuïteit verstoort.

Bestaande "Interleaved Thinking" methoden (waarbij volledige geschiedenis wordt bewaard) zijn niet schaalbaar voor SWE-taken vanwege de frequente tool-gebruik en uitvoerige logs.

Methodologie: SWE-AGILE

SWE-AGILE is een nieuw framework dat de kloof tussen redeneerdiepte, efficiëntie en contextbeperkingen overbrugt door een Dynamische Redeneercontext-strategie te implementeren. Het framework bestaat uit drie kerncomponenten:

1. Dynamische Redeneercontext (Dynamic Reasoning Context)

In plaats van een lineaire groei van de context, introduceert SWE-AGILE een "zaagtand"-patroon:

• Sliding Reasoning Window: De agent behoudt een venster van de laatste $N$ stappen met gedetailleerde redenering ($r_t$) om cognitieve continuïteit te waarborgen en redundantie te voorkomen.
• Reasoning Digests: Historische redeneringen buiten dit venster worden gecomprimeerd tot beknopte samenvattingen, genaamd Reasoning Digests ($d_t$).
• Structuur: Bij elke stap $t$ genereert het model een respons $Y_t = r_t \oplus d_t \oplus a_t$ (Redenering + Digest + Actie). De context $C_t$ bevat dus de volledige interactiegeschiedenis, maar de oude redeneringen zijn vervangen door hun digest.

2. Trajectory Snapshot Training

Om het misalignment tussen training en inferentie op te lossen (waarbij training vaak alle geschiedenis ziet, maar inferentie beperkt is), wordt de training opgesplitst in discrete Snapshots:

• De lange trajecten worden opgedeeld in stappen.
• In elke snapshot wordt de input ($C_t$) gemaskeerd zodat het model alleen de huidige stap moet voorspellen op basis van de gecomprimeerde context (digests voor oude stappen, gedetailleerde redenering voor recente stappen).
• Dit dwingt het model om te leren werken onder de dynamische contextbeperkingen die tijdens de inferentie gelden.

3. Backfilling van Redenering en Digests

Omdat bestaande datasets vaak slechts oppervlakkige gedachtegangen bevatten, gebruikt SWE-AGILE een Hindsight Backfill-pijplijn:

• Een krachtig redenerend model (zoals Qwen3-235B) vult bestaande succesvolle trajecten aan met gedetailleerde System-2 redeneringen ($r_t$) en bijbehorende digestes ($d_t$).
• Dit gebeurt conditioneel op de toekomstige "ground-truth" actie, zodat het model leert hoe men tot de juiste conclusie komt, zelfs als de originele data dit niet expliciet bevatte.

4. Optimalisatie via RLVR met Compressie

Na Supervised Fine-Tuning (SFT) wordt Reinforcement Learning met Verifiable Rewards (RLVR) toegepast met een specifieke Compressie-Reward:

• De beloning functioneert als: $R(\tau) = I_{success} \cdot (1 + \beta \cdot \min(R_{comp}, \gamma))$.
• $I_{success}$ zorgt dat alleen succesvolle trajecten beloning krijgen.
• $R_{comp}$ meet de verhouding tussen de bespaarde tokens (door compressie) en de hypothetische volledige context.
• Dit motiveert het model om diep te redeneren waar nodig (voor complexiteit), maar de digestes zo beknopt mogelijk te houden om contextruimte te besparen, zonder de taakoplossing te veronachtzamen.

Kernresultaten

Het framework is getest op de SWE-Bench-Verified benchmark (500 softwareproblemen van GitHub):

• Prestaties: SWE-AGILE, gebaseerd op een Qwen3-8B model, bereikte een succespercentage van 24,1%.
  • Dit is een verbetering van 35,5% ten opzichte van het basismodel (15,83%).
  • Het presteert beter dan alle bestaande 7B/8B baselines en verslaat zelfs een 14B model (SkyRL-Agent-v0-14B) dat 21,6% haalde.
  • Op een 14B model bereikte het zelfs 30,06%.
• Efficiëntie: Het framework gebruikt slechts 2.2k trainings-trajecten (een fractie van de 19.3k die SWE-Dev gebruikt) en 896 taken voor RLVR.
• Ablatie-studies:
  • Het bewaren van volledige geschiedenis ("Interleaved Thinking") leidde tot een daling in prestaties (12,42%) door het "Lost-in-the-Middle"-effect.
  • SWE-AGILE verminderde de gemiddelde token-lengte per stap met 28% door het gebruik van digestes, wat de cognitieve cache-effectiviteit bevestigt.
  • De compressie-reward verkleinde de lengte van de digestes met 33,4% zonder de succes率 te verlagen.

Bijdragen en Significantie

De belangrijkste bijdragen van dit werk zijn:

1. Paradigmaverschuiving: Het introduceert een hybride contextbeheer dat de voordelen van diepe redenering combineert met de efficiëntie van samenvattingen, waardoor "contextexplosie" wordt voorkomen.
2. Technische Innovatie: De combinatie van Trajectory Snapshot Training en Backfilling lost het probleem op van het trainen van modellen op dynamische contexten zonder complexe attention-maskers te hoeven implementeren.
3. Schaalbaarheid: Het bewijst dat kleinere modellen (7B-8B) met de juiste architectuur en training (SWE-AGILE) concurrent kunnen zijn met veel grotere modellen of methoden die enorme datasets vereisen.
4. Toekomstperspectief: Het framework biedt een solide basis voor het minimaliseren van redundante analyse in agents, wat essentieel is voor het schalen van autonome software-engineering naar langere en complexere taken.

Conclusie: SWE-AGILE lost het fundamentele conflict op tussen de noodzaak van diepe, System-2 redenering en de beperkingen van contextvensters, waardoor agents efficiënter en effectiever kunnen worden in complexe software-engineering taken.