🤖 machine learning

CORVUS: Context Optimization and Reduction Via Underlying Synchronization for LLM Coding Agents

CORVUS introduceert een nieuwe trajectarchitectuur voor LLM-coderingsagenten die file-read-acties ontkoppelt van hun observaties door een gesynchroniseerde registratie van huidige bestandinhoudens bij te houden, waardoor verouderde snapshots en redundante herleesacties worden geëlimineerd om het tokengebruik en de redeneercycli aanzienlijk te verminderen terwijl de prestaties behouden blijven.

Oorspronkelijke auteurs: Mingwei Zheng, David OBrien, Siwei Cui, Pardis Pashakhanloo, Rajdeep Mukherjee, Myeongsoo Kim, Sachit Kuhar

Gepubliceerd 2026-07-28

📖 7 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Mingwei Zheng, David OBrien, Siwei Cui, Pardis Pashakhanloo, Rajdeep Mukherjee, Myeongsoo Kim, Sachit Kuhar

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

Stel je een wereld voor waarin je een super-slimme robotassistent hebt die computercode kan schrijven, bugs kan oplossen en volledige softwareprogramma's kan bouwen door alleen maar met je te praten. Dit is geen sciencefiction; het is de realiteit van "LLM coding agents". Dit zijn kunstmatige intelligentiemodellen die fungeren als junior ontwikkelaars: ze denken over een probleem na, bekijken bestanden, voeren wijzigingen door en controleren hun werk. Maar hier is de crux: deze robots hebben een probleem met hun kortetermijngeheugen. Om te onthouden wat ze hebben gedaan, houden ze een lopend dagboek bij van elke gedachte, actie en resultaat. Hoe complexer de taak, hoe langer dit dagboek wordt. Uiteindelijk wordt het dagboek zo massief dat de robot in de war raakt, belangrijke details vergeet en begin met domme fouten te maken omdat hij een boek van 500 pagina's probeert te lezen om te onthouden wat hij vijf minuten geleden heeft gedaan. Dit fenomeen, waarbij te veel informatie de AI dommer maakt, wordt "context rot" genoemd.

Maak kennis met CORVUS, een slim nieuw systeem ontworpen om deze geheugenrommel op te lossen. In plaats van het de robot toe te staan dat zijn dagboek ongecontroleerd groeit met oude, verouderde aantekeningen, fungeert CORVUS als een magische, levende bibliotheek. Het realiseert zich dat code constant verandert. Als de robot een bestand leest, het vervolgens bewerkt, en het daarna weer leest, is de oude aantekening in het dagboek nutteloze troep. CORVUS voorkomt dat de robot de inhoud van het bestand elke keer opnieuw opschrijft. In plaats daarvan houdt het een "gesynchroniseerde lijst" bij van de bestanden die de robot nodig heeft. Voordat de robot een nieuwe beslissing neemt, controleert CORVUS stilletjes de werkelijke computerbestanden, pakt de allernieuwste versie en overhandigt deze aan de robot. Op deze manier heeft de robot altijd de meest verse, schoonste informatie zonder een dagboek dat opgeblazen is met dubbele, verouderde pagina's. Het resultaat? De robot werkt sneller, kost minder om te draaien en maakt minder fouten, terwijl hij zijn geheugen licht en gefocust houdt.

Het Probleen: De "Stale Snapshot" Valstrik

Om te begrijpen waarom CORVUS een grote zaak is, moeten we eerst kijken naar hoe deze coding agents gewoonlijk werken. Stel je voor dat je probeert een lekkende kraan te repareren, maar dat je dit doet terwijl je een blinddoek draagt en je de kamer alleen kunt zien via een reeks foto's die je eerder hebt gemaakt.

Bij de traditionele methode, elke keer dat de agent (onze robot) een bestand bekijkt, maakt hij een "snapshot" van dat bestand en plakt deze in zijn geschiedenislogboek. Als dat bestand later verandert — omdat de robot het heeft bewerkt, of omdat een menselijke ontwikkelaar er een aanpassing in heeft gedaan — blijft die oude snapshot in het logboek exact hetzelfde. Het wordt stale (verouderd).

De auteurs van het paper ontdekten dat dit twee grote hoofdpijndossiers veroorzaakt:

Dubbele Lezingen: Omdat de oude snapshot diep begraven ligt in een lange geschiedenis, vergeet de robot vaak dat hij het bestand al heeft bekeken. Hij leest het bestand opnieuw, maakt een nieuwe snapshot en plakt deze erin. Dit is alsof je vijf keer dezelfde pagina van een boek leest omdat je je plek bent kwijtgeraakt. In hun tests ontdekten ze dat de robot in 26% van de gevallen bestanden opnieuw las die hij al had gezien.
Stale-Context Fouten: Nog erger is dat de robot een bestand kan proberen te bewerken op basis van een oude snapshot. Stel je voor dat de robot een regel code ziet die zegt: "Regel 10: Doe het licht aan," maar in de echte wereld is die regel vijf minuten geleden verwijderd. De robot probeert "Regel 10" te bewerken, faalt, raakt in de war en moet extra tijd en energie besteden aan het uitzoeken wat er misging.

De oude manier van oplossen was "reactief". Het is alsof je wacht tot je rugzak zo vol zit met stenen dat je hem niet meer kunt tillen, en dan pas probeert wat stenen eruit te gooien. Het paper betoogt dat dit te laat is. De echte oplossing is om te voorkomen dat de stenen überhaupt in de rugzak terechtkomen.

De Oplossing: De "Living Sync"

De auteurs stellen CORVUS voor (Context Optimization and Reduction Via Underlying Synchronization). Zie CORVUS niet als een dagboek, maar als een live feed.

In plaats van de inhoud van een bestand in het geschiedenislogboek te plakken, gebruikt CORVUS een speciale tool genaamd sync_file. Wanneer de robot zegt: "Ik moet speech_recognition.py bekijken," kopieert CORVUS de tekst niet in het logboek. In plaats daarvan plaatst het een kleine, lichtgewicht aantekening in het logboek die zegt: "Sync: speech_recognition.py."

Achter de schermen onderhoudt CORVUS een Synced File Set. Dit is een speciale lijst met bestanden waar de robot momenteel aan werkt. Voordat de robot een nieuwe beslissing neemt (elke enkele redeneercyclus), voert CORVUS een snelle "Context Sync" uit. Het gaat naar de eigenlijke computer, haalt de huidige, nieuwste versie van elk bestand op dat lijstje, en injecteert deze in de prompt van de robot.

Dit verandert alles:

Geen Duplicaten: De robot ziet nooit twee versies van hetzelfde bestand. Hij ziet alleen de ene, huidige versie.
Geen Verouderde Data: Als een bestand verandert, krijgt de robot de nieuwe versie automatisch de volgende keer dat hij nadenkt. Hij probeert nooit code te bewerken die niet meer bestaat.
Lichter Gewicht: Het geschiedenislogboek blijft klein omdat het alleen de gedachten en acties van de robot bevat, niet massieve blokken bestandstekst.

Wat Ze Vonden: Sneller, Goedkoper, Slimmer

De onderzoekers testten CORVUS op twee uitdagende programmeeropdrachten: SWE-POLYBENCH_VERIFIED (die taken in Java, JavaScript en TypeScript bevat) en SWE-BENCH PRO (die complexe, enterprise-niveau problemen bevat). Ze voerden deze tests uit op vier verschillende krachtige AI-modellen, waaronder CLAUDE SONNET 4 en QWEN3-CODER-480B.

De resultaten waren indrukwekkend en lieten zien dat het vers houden van de context de AI aanzienlijk efficiënter maakt:

Minder Verspilde Leestijd: CORVUS verminderde dubbele bestand-lezingen met 22% tot 86%. De robot stopte met het verspillen van tijd aan het opnieuw lezen van bestanden die hij al kende.
Minder Stappen: Omdat de robot niet in de war raakte door oude data, voltooide hij taken sneller. Het aantal redeneercycli (stappen) daalde met 15% tot 37%. Bij een model daalde het aantal stappen bijvoorbeeld van een gemiddelde van 45,03 naar 28,22.
Kortere Prompts: De uiteindelijke "prompt" (het bericht dat naar de AI wordt gestuurd om de taak te voltooien) was 15% tot 32% korter.
Geld Bespaard: Omdat AI geld kost op basis van hoeveel tekst het verwerkt, telden deze besparingen snel op. Bij sommige taken daalden de kosten met wel 50,28%. Zo daalde een taak die $5,27 kostte naar $2,62.
Snelheid: Het hele proces werd tot wel 40% sneller voltooid in termen van totale tijd.

Cruciaal is dat het paper opmerkt dat de robot niet dommer werd door minder tekst te hoeven lezen. Het succespercentage (hoe vaak het de bug correct oploste) bleef vergelijkbaar met de oude methode, en in sommige gevallen zelfs iets verbeterd.

Het Grotere Plaatje

De auteurs controleerden ook of CORVUS werkt met andere methoden die proberen rommelige geschiedenissen op te schonen. Ze vonden dat COR-VUS en deze "reactieve" opschoningsinstrumenten beste vrienden zijn. CORVUS voorkomt dat de rommel aan de bron ontstaat (upstream), terwijl de andere instrumenten opruimen wat er nog overblijft (downstream). Wanneer ze samen worden gebruikt, besparen ze nog meer tokens en geld.

Kortom, CORVUS suggereert dat voor AI-coding agents om echt efficiënt te zijn, ze niet alleen goed moeten zijn in het onthouden van het verleden; ze moeten ook goed zijn in het verbonden blijven met het heden. Door de actie van het "lezen van een bestand" los te koppelen van de "inhoud van het bestand", en in plaats daarvan een live sync met de codebase te behouden, kunnen we agents bouwen die sneller, goedkoper en minder vatbaar zijn voor de verwarring van "context rot". Het paper beweert niet dat dit elk probleem in AI oplost, maar het laat zien dat een eenvoudige structurele verandering — het vervangen van een statisch dagboek door een live feed — een enorm verschil kan maken in hoe goed deze digitale assistenten werken.

Technische Samenvatting: CORVUS

Probleem: Contextrot en Append-only Trajecten

Large Language Model (LLM) programmeeragenten opereren via een iteratieve Thought–Action–Result loop, waarbij ze een "traject" (interactiegeschiedenis) als werkgeheugen bijhouden. Conventionele agenten maken gebruik van een append-only trajectarchitectuur, waarbij acties voor het lezen van bestanden nauw gekoppeld zijn aan hun observaties. Wanneer een agent een bestand leest, wordt een momentopname van de inhoud van dat bestand op dat specifieke tijdstip permanent toegevoegd aan de chronologische geschiedenis.

Deze architectuur creëert twee primaire inefficiënties, met name bij software engineering-taken met een lange horizon:

Dubbele Bestand-leesacties: Naarmate het traject groeit, raken relevante bestandinhoudens begraven in de context ("lost in the middle" fenomeen). Agenten lezen bestanden vaak opnieuw om informatie op te halen, waarbij redundante volledige bestandssnapshots aan de geschiedenis worden toegevoegd. Empirische analyse toonde aan dat 26% van de bestand-leesoperaties in baseline-agenten duplicaten waren.
Stale-Context Fouten: Omdat snapshots onveranderlijk (immutable) zijn, weerspiegelen ze geen daaropvolgende wijzigingen door de agent of gelijktijdige menselijke aanpassingen. Agenten kunnen proberen code te bewerken op basis van verouderde regelnummers of variabelenamen, wat leidt tot mislukte bewerkingen. Herstel vereist extra diagnosecycli en verdere bestand-leesacties, wat de traject-opzwelling verergert.

Deze problemen dragen bij aan contextrot, waarbij een toenemende promptlengte de nauwkeurigheid van het model en de betrouwbaarheid van de redenering verslechtert, terwijl het tegelijkertijd de tokenkosten en de inferentie-latentie verhoogt. Bestaande methoden voor contextbeheer zijn grotendeels reactief; ze comprimeren of snoeien de context pas nadat deze is geaccumuleerd. Ze voorkomen niet de introductie van onnodige of verouderde inhoud bij de bron.

Methodologie: CORVUS Architectuur

Het artikel stelt CORVUS voor (Context Optimization and Reduction Via Underlying Synchronization), een proactieve trajectarchitectuur die bestand-leesacties ontkoppelt van hun observaties. In plaats van vaste snapshots op te slaan, onderhoudt CORVUS een gesynchroniseerde registratie van relevante bestanden.

Kernmechanismen

Gesynchroniseerde Bestandsset ( $S_t$ ): CORVUS introduceert een dynamische registratie van bestanden die relevant zijn voor de huidige taak. Wanneer een agent met een bestand moet interageren, roept hij een nieuwe tool aan, sync_file(fj), in plaats van read_file(fj).
- De sync_file tool registreert het bestand in de set $S_t$ , maar voegt slechts een lichtgewicht marker toe (bijv. "sync: ./path/to/file") aan de trajectgeschiedenis, waardoor de directe inclusie van de bestandsinhoud wordt vermeden.
Context Synchronisatie Fase: Vóór elke redeneercyclus vindt een synchronisatiestap plaats die de context ververst. Het systeem haalt de huidige inhoud van alle bestanden in de gesynchroniseerde set uit de repository.
Prompt Compositie: De prompt voor elke redeneerstap wordt geconstrueerd als:
$P_t = M_{sys} \oplus T_{schema} \oplus H_{t-1} \oplus C_t$
Waarbij $C_t$ de Gesynchroniseerde Context is, die maximaal één huidige versie van elk geregistreerd bestand bevat. Dit zorgt ervoor dat de agent redeneert over de nieuwste staat van de codebase zonder historische, potentieel verouderde bestandssnapshots mee te dragen in de berichtgeschiedenis.

Deze structurele wijziging zorgt ervoor dat het traject door constructie gesynchroniseerd blijft met de werkelijke status van de repository, waardoor redundante kopieën worden geëlimineerd en het voorkomen wordt dat de agent redeneert over verouderde informatie.

Belangrijkste Bijdragen

Het artikel levert drie primaire bijdragen:

Identificatie van Structurele Inefficiëntie: De auteurs identificeren empirisch dat de standaard append-only trajectarchitectuur ervoor zorgt dat veranderlijke bestandsinhouden worden behandeld als onveranderlijke geschiedenis-entries, wat leidt tot de accumulatie van dubbele en verouderde snapshots.
Proactieve Architectuur (CORVUS): Zij stellen CORVUS voor, dat inline bestand-leesacties vervangt door een sync_file mechanisme en een pre-cycle contextverversing. Dit garandeert dat de prompt alleen de huidige versie van relevante bestanden bevat, waardoor traject-opzwelling bij de bron wordt voorkomen.
Uitgebreide Evaluatie: Het systeem is geïmplementeerd op het STRANDS AGENTS framework en geëvalueerd over vier LLM's (drie propriëtair: Claude Sonnet 3.7, 4, 4.5; één open-source: Qwen3-Coder-480B) op twee benchmarks: SWE-POLYBENCH_VERIFIED en SWE-BENCH PRO.

Resultaten

Evaluatie over 573 instanties toonde aan dat CORVUS de traject-efficiëntie aanzienlijk verbetert terwijl de taaksuccesratio's behouden blijven:

Verminderde Redundantie: Dubbele bestand-leesacties werden met 22–86% verminderd over alle modellen.
Minder Redeneercycli: Het aantal redeneercycli dat nodig is om taken te voltooien, nam af met 9–37%, waarbij de grootste reductie (37,33%) werd waargenomen bij Claude Sonnet 4.5 op SWE-POLYBENCH_VERIFIED.
Kortere Prompts: De uiteindelijke request-prompts werden met 15–32% verkort, wat het gebruik van het maximale contextvenster vermindert.
Token- en Kostenbesparingen: Gemiddelde input-tokens per taak werden met 9–50% verminderd. Totale tokenkosten werden met wel 51% verlaagd (bijv. van $5,27 naar $2,62 per instantie voor Claude Sonnet 4.5 op SWE-POLYBENCH_VERIFIED).
Runtime Efficiëntie: De end-to-end latentie werd met maximaal 40% verminderd. De synchronisatie-overhead (lokale bestand-leesacties) was verwaarloosbaar vergeleken met de besparingen door minder LLM-inferentiecycli.
Taaksucces: De Pass@1-percentages bleven vergelijkbaar met baseline-agenten, met lichte verbeteringen in drie van de vier modellen, wat aangeeft dat de efficiëntiewinst de correctheid niet heeft aangetast.

Compatibiliteit: Het artikel toont verder aan dat CORVUS complementair is aan reactieve contextbeheermethoden (bijv. sliding windows, samenvatting). Het combineren van CORVUS met reactieve strategieën levert verdere reducties in tokens en kosten op, wat suggereert dat een hybride aanpak optimaal is.

Betekenis en Claims

Het artikel claimt dat proactieve codebase-traject synchronisatie een cruciale, maar voorheen over het hoofd geziene optimalisatie is voor langdurige coderingsagenten. Door de kernoorzaak van contextrot aan te pakken — de koppeling van veranderlijke bestandstoestanden aan onveranderlijke geschiedenis-entries — maakt CORVUS efficiëntere en betrouwbaardere agentische workflows mogelijk.

De auteurs benadrukken dat hun aanpak onderscheidt van reactieve compressie; het voorkomt de accumulatie van verouderde data in plaats van het later op te schonen. De resultaten suggereren dat het handhaven van een gesynchroniseerd beeld van de repository agenten in staat stelt om met lichtere trajecten te werken, wat kosten en latentie verlaagt terwijl het vermogen om complexe software engineering-taken op te lossen behouden blijft. Het artikel concludeert dat deze architecturale verschuiving essentieel is voor het schalen van LLM-coderingsagenten naar enterprise-grade, meerdaagse ontwikkelingsworkflows.