SWE-Pruner: Self-Adaptive Context Pruning for Coding Agents

1. Probleemstelling

Large Language Model (LLM) agents hebben een opmerkelijk potentieel getoond in software-engineeringstaken, variërend van codebegrip tot autonome patchgeneratie. Hun effectiviteit wordt echter ernstig gehinderd door de "Context Wall":

• Token-accumulatie: Real-world software-repositories zijn enorm. Agents die door deze repositories navigeren, accumuleren lange interactiegeschiedenissen en ruwe bestandsinhoud, waardoor de contextvensters zelfs van modellen met lange context snel worden uitgeput.
• Kosten en latentie: Het blindelings inname van grote hoeveelheden code leidt tot verbodsdure API-kosten en hoge inferentie-latentie.
• Aandachtverdunning: Excessive context introduceert ruis, wat leidt tot "aandachtverdunning" en hallucinaties, waarbij het model de focus op kritieke implementatiedetails verliest.
• Beperkingen van bestaande oplossingen: Huidige methoden voor contextcompressie (bijv. LongLLMLingua, Selective-Context) vertrouwen op statische metrieken zoals Perplexity (PPL) of zelfinformatie. Deze methoden zijn taakagnostisch en werken vaak op token-niveau, wat de syntactische en logische structuur van code verstoort, waardoor deze onbruikbaar wordt voor debugging of compilatie. Ze falen in het aanpassen aan de dynamische, evoluerende doelen van multi-turn agent-interacties.

2. Methodologie: SWE-Pruner

De auteurs stellen SWE-Pruner voor, een zelfadaptief context-pruning framework dat specifiek is ontworpen voor coderende agents. Het fungeert als middleware tussen de agent en de omgeving, waarbij het bestandsleescommando's (bijv. cat, grep) onderschept om ruwe context te filteren voordat deze de LLM bereikt.

Kerncomponenten

1. Goal Hint-generatie:

   • In plaats van statische compressie, wordt de agent geïnstrueerd om een Goal Hint te genereren—een natuurlijke taalbeschrijving van zijn huidige informatiebehoefte (bijv. "Focus op foutafhandelingslogica in de Auth-module").
   • Deze hint wordt doorgegeven als een optionele parameter (context_focus_question) aan het pruning-systeem, waardoor taakbewuste filtering mogelijk wordt.

2. Lightweight Neural Skimmer:

   • Architectuur: Een model met 0,6B parameters gebaseerd op Qwen3-Reranker-0.6B. Het is ontworpen voor lage latentie en hoge efficiëntie.
   • Mechanisme: De skimmer behandelt context-pruning als een herrangschikkingsprobleem. Gegeven een query (Goal Hint) en een context (ruwe bestandsinhoud), berekent het relevantiescores.
   • Granulariteit op lijnniveau: In tegenstelling tot pruning op token-niveau, aggregeert SWE-Pruner tokenscores naar lijnniveau. Dit zorgt ervoor dat syntactische structuren (bijv. functiedefinities, klassenblokken) intact blijven, wat codebreuk voorkomt.
   • Trainingsdoel: Het model is getraind met een Conditional Random Field (CRF)-verlies om sequentiële afhankelijkheden tussen "behouden" en "prunen"-beslissingen te modelleren, wat coherente retentie op lijnniveau garandeert. Het bevat ook een herrangschikkingskop op documentniveau om globale relevantie te behouden.

3. Constructie van trainingsdata:

   • Aangezien er geen dataset bestaat met annotaties voor relevantie op lijnniveau voor coderende agents, hebben de auteurs een polyglot-corpus van 61K samples geconstrueerd met behulp van een teacher-student paradigma.
   • Een teacher LLM (Qwen3-Coder-30B) synthetiseerde taakgerichte queries en maskers voor retentie op lijnniveau vanuit GitHub-repositories, waarbij negen verschillende agentische taken werden bestreken (bijv. debugging, refactoring, toevoegen van functies).
   • Een "LLM-as-a-Judge"-mechanisme filterde de data om annotaties van hoge kwaliteit te waarborgen.

4. Integratiewerkflow:

   • Het framework is geïntegreerd in agent-loops (bijv. Mini SWE Agent, OpenHands). Wanneer een agent een bestand leest, wordt de ruwe output samen met de Goal Hint naar de skimmer gestuurd. De skimmer retourneert een Pruned Context die alleen de relevante regels bevat, die de agent vervolgens verwerkt.

3. Belangrijkste bijdragen

• Taakbewust pruning-framework: Introductie van een nieuwe aanpak die contextcompressie dynamisch aanpast aan de specifieke redeneringsdoelen van de agent, verdergaand dan statische, alleen-inhoudsgerichte compressie.
• Behoud van structuur op lijnniveau: Ontwerp van een lightweight neural skimmer die op lijnniveau werkt, waardoor syntactische geldigheid en logische structuur worden behouden, wat cruciaal is voor code-correctheid.
• Efficiënte architectuur: Ontwikkeling van een model met 0,6B parameters dat verwaarloosbare latentie introduceert (<100ms) terwijl het aanzienlijke tokenreductie bereikt, waardoor het praktisch toepasbaar is voor real-time agent-werkflows.
• Synthetische data-pijplijn: Creëren van een rigoureuze pijplijn voor het genereren van hoogwaardige, gesuperviseerde data op lijnniveau voor code-pruning, waarmee een kritiek data-gat in het veld wordt gedicht.

4. Experimentele resultaten

De auteurs hebben SWE-Pruner geëvalueerd over vier benchmarks: SWE-Bench Verified en SWE-QA (multi-turn agent-taken), en Long Code Completion en Long Code QA (single-turn taken).

• Multi-turn agent-taken (SWE-Bench Verified):

  • Tokenreductie: Bereikte een reductie van 23–38% in het totale tokenverbruik.
  • Succespercentage: Verrassend genoeg verbeterden de succespercentages met 1,2–1,4 procentpunten (bijv. van 70,6% naar 72,0% met Claude Sonnet 4.5).
  • Efficiëntie: Verminderde interactierondes met 18–26%, wat aangeeft dat agents met gefocuste context doordachtere beslissingen nemen.
  • Kosten: Aanzienlijke reductie in API-kosten (tot wel ~36% besparing).

• Single-turn taken (Long Code QA/Completion):

  • Compressieverhouding: Bereikte tot 14,84× compressie op Long Code QA onder strikte beperkingen, wat ver voorbijgaat aan baselines zoals LLMLingua2 en RAG.
  • Prestaties: Behield of verbeterde de nauwkeurigheid licht (bijv. 58,71% nauwkeurigheid bij 14,84× compressie) vergeleken met volledige context, terwijl baselines op token-niveau zware prestatiedegradatie leden onder hoge compressie.

• Efficiëntie & Latentie:

  • De 0,6B skimmer voegt minimale overhead toe (<100ms first-token latentie), wat wordt gecompenseerd door de massale reductie in downstream LLM-decodingkosten.
  • AST-correctheid: SWE-Pruner behield 87,3% AST-correctheid (syntactische geldigheid), wat aanzienlijk beter presteert dan methoden op token-niveau (die daalden tot bijna 0% of <13%).

5. Betekenis

• Oplossen van de Context Wall: SWE-Pruner biedt een schaalbare oplossing voor de beperkingen van het contextvenster van coderende agents, waardoor ze grote, complexe codebases kunnen navigeren zonder verbodsdure kosten of verlies van focus.
• Paradigmaverschuiving: Het verschuift contextbeheer van statische compressie naar dynamische, doelgestuurde selectie, wat nabootst hoe menselijke ontwikkelaars code "scannen" op basis van specifieke debugging- of functiedoelen.
• Praktische levensvatbaarheid: Het framework is lichtgewicht, modelagnostisch (werkt met Claude, GLM, Qwen, enz.) en integreert naadloos als middleware, waardoor het direct toepasbaar is op bestaande agent-infrastructuur.
• Kwaliteit boven kwantiteit: De resultaten tonen aan dat minder context vaak beter is voor coderende agents, mits de behouden context structureel intact is en semantisch relevant voor de huidige taak. Dit daagt de heersende aanname "meer context is beter" uit in het onderzoek naar lange context LLM's.