💻 computer science

Squeez: Task-Conditioned Tool-Output Pruning for Coding Agents

Het paper introduceert Squeez, een methode die een klein, op de taak afgestemd model gebruikt om 92% van de tool-uitvoer van coderingsagenten te verwijderen terwijl de herinneringsprestaties worden verbeterd, wat aanzienlijk beter presteert dan grotere zero-shot modellen en heuristische baselines.

Oorspronkelijke auteurs: Ádám Kovács

Gepubliceerd 2026-04-08

📖 4 min leestijd☕ Koffiepauze-leesvoer

CC BY 4.0

Oorspronkelijke auteurs: Ádám Kovács

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

🧐 Het Probleem: De "Grote Hoop" Informatie

Stel je voor dat je een detective bent die een complex misdrijf moet oplossen. Je krijgt elke dag een enorme stapel documenten: getuigenverhoren, foto's, bankafschriften, e-mails en video's.

Het probleem is dat 90% van die documenten nutteloos is voor de specifieke vraag die je nu hebt. Misschien zoek je naar een specifieke getuige, maar krijg je 500 pagina's aan bankafschriften die niets met die getuige te maken hebben.

In de wereld van computerprogramma's die code schrijven (zogenoemde "coding agents"), gebeurt precies dit. Deze programma's krijgen constant enorme hoeveelheden informatie: foutmeldingen, lange logbestanden, code uit duizenden bestanden en versiegeschiedenis. Ze moeten vaak de hele tekst opnieuw lezen om één klein stukje te vinden dat belangrijk is. Dit is traag, duur en verwarrend voor de computer.

✂️ De Oplossing: "Squeez" (De Knijper)

De onderzoekers van dit paper hebben een slimme oplossing bedacht genaamd Squeez.

Je kunt Squeez vergelijken met een slimme assistent die naast je zit.

Jij zegt tegen de assistent: "Ik zoek de reden waarom de koffieautomaat stopte."
De assistent krijgt een stapel van 500 pagina's aan onderhoudsrapporten.
In plaats van jou de hele stapel te geven, knijpt de assistent de stapel in. Hij haalt er alleen de twee regels uit die zeggen: "Koffieautomaat stopte door gebrek aan water."
Hij geeft je die twee regels en gooit de rest weg.

Het doel: De computer hoeft niet meer de hele berg te lezen, maar alleen het kleine stukje dat echt belangrijk is.

🛠️ Hoe werkt het?

De onderzoekers hebben een speciale "trainer" (een klein AI-model) gemaakt.

De training: Ze hebben de AI duizenden voorbeelden gegeven van vragen en enorme stukken tekst. De AI leerde telkens: "Als de vraag dit is, dan is dit het enige stukje tekst dat relevant is."
De slimme keuze: Ze gebruikten een heel klein model (Qwen 3.5 2B). Je zou denken dat een grotere, slimmere AI beter zou zijn, maar dat bleek niet zo. Een kleine, goed getrainde "specialist" werkt hier veel sneller en beter dan een enorme, algemene "generalist".

🏆 De Resultaten: Een Verpletterende Overwinning

De onderzoekers testten hun systeem tegen andere methoden:

De "Grote Broer": Een enorm, duur AI-model dat alles zelf probeert te begrijpen zonder training.
De "Simpele Trucjes": Methoden die gewoon de eerste 10 regels nemen, of de laatste 10 regels, of willekeurige regels kiezen.

Het resultaat?
De kleine, getrainde "Squeez"-assistent was veel beter dan de grote AI en de simpele trucjes.

Hij vond 86% van de belangrijke stukjes (terwijl de grote AI maar 75% vond).
Hij verwijderde 92% van de overbodige tekst.
Hij was ook nog eens veel sneller en goedkoper in gebruik.

🌍 Waarom is dit belangrijk?

Vroeger dachten mensen: "Hoe groter de AI, hoe beter."
Dit paper laat zien dat voor specifieke taken (zoals het vinden van een naald in een hooiberg) een kleine, goed getrainde specialist veel effectiever is dan een enorme, dure machine die alles probeert te doen.

De kernboodschap in één zin:
In plaats van een hele berg informatie te laten lezen aan een computer, geef je hem een slimme schaar die precies weet wat hij moet knippen. Hierdoor werken programmeer-robots veel sneller en slimmer.

🚀 Wat betekent dit voor de toekomst?

Dit systeem kan nu direct worden ingebouwd in bestaande programmeer-tools. Het werkt als een filter: voordat de computer de zware "denk-taak" doet, wordt de informatie eerst "geknijpt" tot de essentie. Dit bespaart tijd, geld en energie, en maakt AI-assistenten voor programmeurs veel praktischer.

Probleemstelling

Coderingsagents (AI-agenten voor softwareontwikkeling) genereren en consumeren voortdurend lange stromen van tool-observaties, zoals bestandslezingen, grep-hits, stacktraces, build-logs en API-responses. Een fundamenteel inefficiëntie-probleem is dat slechts een klein fractie van deze tokens relevant is voor de volgende beslissing van de agent, maar de agent moet vaak de volledige output opnieuw lezen. Dit leidt tot een enorme token-kost en vertraagt het redeneerproces.

Bestaande oplossingen zoals prompt-compressie (bijv. LLMLingua) of documentretrieval zijn niet optimaal voor deze context omdat ze vaak werken op prozatekst of losse passages, terwijl tool-output een gemengd formaat bevat (code, logs, metadata, gestructureerde data) dat verbatim (letterlijk) bewaard moet blijven. Het doel is niet om het probleem op te lossen, maar om de minimale, relevante bewijsblokken te extraheren en de rest te verwijderen.

Methodologie

1. Taakdefinitie: Task-Conditioned Tool-Output Pruning
De auteurs definiëren de taak als het selecteren van de kleinste verbatim-bewijsblokken uit een enkele tool-observatie ( $o$ ), gegeven een gefocuste query ( $q$ ).

Input: Een paar $(q, o)$ , waarbij $q$ een korte, concrete vraag is (bijv. "Vind de traceback die de ImportError verklaart") en $o$ de ruwe tool-output is.
Output: Een set van contiguïteitsblokken (regels) uit de originele output die de query beantwoorden.
Verschil met andere taken: Het is geen generatieve oplossing voor bugs, maar een extractieve filtratie-taak waarbij de integriteit van de broncode/logs behouden blijft.

2. Dataset en Benchmark
De auteurs hebben een nieuwe benchmark ontwikkeld met in totaal 11.477 voorbeelden, samengesteld uit twee bronnen:

SWE-bench afgeleid: 10.713 ruwe observaties gegenereerd door 14 verschillende tool-types (zoals file read, git log, pytest, pip install) op repositories uit SWE-bench.
Synthetisch multi-ecosysteem: 2.039 realistische tool-output voor TypeScript, Go, Rust, Java, Docker, etc., gegenereerd met een groot taalmodel. Daarnaast zijn 575 "negatieve voorbeelden" toegevoegd (waarbij de query niet beantwoord kan worden door de observatie).
Curation: Een handmatig gecurateerde testset van 618 voorbeelden (na filtering van dubbelingen en triviale gevallen) wordt gebruikt voor evaluatie.

3. Model en Training

Architectuur: Een compact Qwen 3.5 2B model, gefinetuned met LoRA (Low-Rank Adaptation).
Training: Het model leert de gefocuste query en de ruwe output te verwerken en de relevante regels te genereren, omhuld in XML-tags (<relevant lines>).
Inspiratie: De keuze voor een klein model (2B parameters) is strategisch: het moet een goedkope, gespecialiseerde "filter" zijn die in bestaande agent-stacks (zoals Codex of Claude Code) kan worden ingebouwd zonder de core-logica te veranderen.

4. Evaluatiemetrics
De prestaties worden gemeten op basis van:

Recall: Hoeveel van de relevante regels (gold spans) worden gevonden?
F1-score: Een tolerantie-maatstaf voor lijn-overlap (fuzzy substring similarity > 0.5).
Compressie: Het percentage van de invoer dat wordt verwijderd.
Baselines: Vergelijking met grotere zero-shot modellen (Qwen 35B, Kimi K2) en heuristieken (BM25, First-N, Last-N, Random).

Belangrijkste Resultaten

Het gefinetunde Squeez-2B model presteert aanzienlijk beter dan alle andere systemen:

Recall: 0.86 (vergeleken met 0.75 voor Qwen 35B en 0.53 voor Kimi K2).
F1-score: 0.80.
Compressie: Het verwijdert 92% van de invoertokens terwijl het de relevantie behoudt.
Vergelijking: Het overtreft het 18x grotere Qwen 3.5 35B model met 11 recall-punten en alle heuristische baselines met een grote marge (heuristieken halen vaak <0.22 recall).

Kwalitatieve bevindingen:

Het model leert specifieke patronen te herkennen in gestructureerde output (zoals git log of grep).
Het is uitstekend in het teruggeven van een lege output bij negatieve voorbeelden (waar geen relevant bewijs is), terwijl zero-shot modellen vaak hallucineren of onnodige tekst genereren.
De fouten die het model maakt, zijn meestal "semantisch aangrenzende" selecties (bijv. een verkeerde commit uit dezelfde module) in plaats van volledig irrelevante output.

Bijdragen en Significantie

Nieuwe Benchmark: De paper introduceert de eerste gestructureerde benchmark voor het filteren van tool-output specifiek voor coderingsagents, met een focus op gemengde formaten en verbatim-extractie.
Efficiëntie vs. Prestatie: Het bewijst dat een klein, gespecialiseerd model (2B parameters) superieur is aan enorme zero-shot modellen voor specifieke extractietaken. Dit maakt het mogelijk om dure agent-systemen te optimaliseren door een goedkope "pre-processing" stap toe te voegen.
Praktische Toepasbaarheid: Het model kan eenvoudig worden geïntegreerd in bestaande agent-workflows (via CLI of vLLM) om de contextgrootte drastisch te verkleinen zonder de redeneercapaciteit van de hoofdagente te verliezen.
Inzicht in Tool-Output: De resultaten tonen aan dat generatieve modellen en traditionele zoekalgoritmen (zoals BM25) slecht presteren op de complexe, niet-lineaire aard van tool-logs, en dat taak-specifieke supervisie essentieel is.

Conclusie:
"Squeez" biedt een praktische oplossing voor de "context-overload" in coderingsagents. Door 92% van de irrelevante tokens te verwijderen met behoud van hoge recall, stelt het onderzoek een nieuwe standaard voor efficiënte agent-systemen en demonstreert het dat gespecialiseerde, kleine modellen de sleutel zijn tot schaalbare AI-agenten. De code, dataset en modellen zijn open source beschikbaar.