LCM: Lossless Context Management

Dit artikel introduceert Lossless Context Management (LCM), een deterministische architectuur die het geheugen van LLM's verbetert door middel van recursieve contextcompressie en taakpartitionering, waardoor de Volt-agent lang-context programmeertaken tot 1 miljoen tokens beter presteert dan Claude Code, met garantie van verliesvrije staatsherwinning en beëindiging.

De kern

Stel je voor dat je probeert een massaal, meerdaags mysterie op te lossen. Je hebt een briljante detective (de AI), maar die heeft een zeer kortetermijngeheugen. Als je ze een stapel van 1.000 aanwijzingen geeft, zullen ze de eerste paar vergeten tegen de tijd dat ze bij de laatste aankomen.

Lange tijd was de oplossing om de detective gewoon een groter notitieboek te geven (een groter "contextvenster"). Maar uiteindelijk worden zelfs de grootste notitieboeken te zwaar om te dragen, en begint de detective door de enorme hoeveelheid papier in de war te raken.

Dit paper introduceert een nieuwe manier om de detective te helpen: Lossless Context Management (LCM). Denk hierbij aan het geven van een superintelligente, geautomatiseerde bibliothecaris aan de detective die de notities voor hen beheert, in plaats van de detective te vragen hun eigen archiefsysteem te schrijven.

Hier is hoe het werkt, met eenvoudige analogieën:

1. Het Probleem: De "GOTO" versus "Gestructureerde" Debat

Het paper vergelijkt twee manieren om geheugen te hanteren:

• De Oude Weg (RLM): Stel je voor dat je de detective vraagt hun eigen archiefsysteem in code te schrijven. Ze moeten beslissen hoe ze de notities organiseren, wanneer ze dingen wegdoen en hoe ze ze later terugvinden. Dit is alsof je een programmeur onbeperkte vrijheid geeft om GOTO-statements te gebruiken (overal in de code springen). Het is krachtig, maar als de detective een fout maakt in hun archiefscript, crasht het hele systeem of wordt het rommelig.
• De Nieuwe Weg (LCM): In plaats van de detective te vragen het archiefsysteem te schrijven, biedt de engine (de computer die de detective draait) een vooraf gebouwd, perfect archiefkastje. De detective zegt gewoon: "Hier is een nieuwe aanwijzing," en de engine beslist automatisch wanneer oude aanwijzingen samengevat moeten worden en waar ze opgeslagen moeten worden. Dit is alsof je gestructureerde programmering gebruikt (loops en if-statements): het is minder flexibel, maar het crasht nooit door slechte logica.

2. De Twee Magische Hulpmiddelen van LCM

Het paper stelt dat LCM twee hoofdtuigen gebruikt om de detective gefocust te houden:

A. Het "Verliesvrije" Archiefkastje (Hiërarchische DAG)

• Hoe het werkt: De engine houdt een "Hoofdkopie" van elke enkele notitie, woord voor woord, in een beveiligde kluis (de Immutable Store).
• De Samenvatting: Om ruimte te besparen in de actieve werkruimte van de detective, maakt de engine een "samenvattingskaart" voor oude notities. Het plaatst de samenvattingskaart in de werkruimte en verbergt de volledige notitie in de kluis.
• De Magie: Als de detective later de originele notitie nodig heeft, kunnen ze erom vragen, en de engine ruilt de samenvattingskaart direct in voor de volledige notitie. Niets gaat ooit echt verloren; het wordt alleen gecomprimeerd tot het nodig is.
• Analogie: Stel je voor dat je een boek van 500 pagina's leest. In plaats van het hele boek mee te nemen, draag je een bladwijzer met een samenvatting van één zin per hoofdstuk. Als je een detail moet controleren, sla je terug naar de specifieke pagina in het boek. Je verliest de originele tekst nooit.

B. Het "Parallelle" Team (LLM-Map)

• Het Probleem: Als de detective 1.000 bestanden één voor één moet lezen, raken ze moe en vergeten ze het eerste bestand tegen de tijd dat ze het laatste bereiken.
• De Oplossing: In plaats van dat de detective de bestanden zelf leest, fungeert de engine als een baas die 16 assistenten huurt. De detective geeft de baas één instructie: "Lees deze 1.000 bestanden en vertel me het hoofdpunt van elk." De engine stuurt alle 1.000 bestanden gelijktijdig naar de assistenten.
• Het Resultaat: De assistenten doen het zware werk parallel. De detective ziet alleen de uiteindelijke, georganiseerde lijst met resultaten. De detective hoeft nooit 1.000 bestanden tegelijk in hun hoofd te houden.

3. De "Zero-Cost" Belofte

Een van de grootste claims van het paper is dat dit systeem de dingen niet vertraagt voor kleine taken.

• Analogie: Als je maar 5 notities hebt om te archiveren, maakt de engine zich geen zorgen om een complex archiefsysteem te creëren. Het laat de detective ze gewoon direct lezen. Het "archiefkastje" springt pas in actie als de stapel te groot wordt. Dit betekent dat voor normale, korte gesprekken het systeem net zo snel aanvoelt als een standaard AI.

4. De Resultaten: De Concurrentie Verslaan

De auteurs testten hun systeem (genaamd Volt) tegen Claude Code, dat momenteel een van de beste AI-coding-assistenten ter wereld is.

• De Test: Ze gaven beide systemen een massaal "mysterie" met tot wel 1 miljoen woorden aanwijzingen (tokens).
• De Uitkomst:
  • Voor kleine aanwijzingen (minder dan 32.000 woorden) presteerden beide systemen ongeveer even goed.
  • Voor enorme aanwijzingen (32.000 tot 1 miljoen woorden) won Volt elke keer.
  • Het paper beweert dat Volt aanzienlijk beter was in het vinden van het juiste antwoord in enorme datasets omdat het niet "in de war" raakte door de hoeveelheid tekst, terwijl Claude Code begon te worstelen naarmate de tekst langer werd.

5. Waarom Dit Belangrijk Is (Volgens Het Paper)

Het paper betoogt dat het vragen aan een AI om zijn eigen geheugen te beheren (zoals de "Oude Weg") riskant is omdat AI fouten kan maken in zijn eigen code. Door het geheugenbeheer naar de computer-engine te verplaatsen (de "Nieuwe Weg"), wordt het systeem:

1. Betrouwbaarder: Het crasht niet omdat de AI een slecht script heeft geschreven.
2. Efficiënter: Het verwerkt enorme hoeveelheden data zonder dat de AI overweldigd raakt.
3. Verliesvrij: Het garandeert dat geen enkele informatie ooit echt wordt verwijderd, alleen samengevat.

Kortom, het paper suggereert dat voor zeer lange, complexe taken het beter is om de AI een gestructureerde, geautomatiseerde assistent te geven om het geheugen te behandelen, in plaats van de AI zelf de bibliothecaris te laten zijn.

Technische samenvatting

Technische Samenvatting: Verliesvrije Contextbeheer (LCM)

Probleemstelling

De primaire bottleneck voor complexe, langdurige agentische taken blijft het effectieve contextvenster van Large Language Models (LLM's). Zelfs modellen met nominale vensters die 1 miljoen tokens overschrijden, hebben moeite met sessies van meerdere dagen waarbij het volume aan tool-aanroepen, bestandsinhoud en tussenstappen in het redeneren de capaciteit overstijgt. Dit wordt verergerd door "contextrot", waarbij de prestaties aanzienlijk verslechteren voordat de harde tokenlimiet wordt bereikt.

Vorig werk, specifiek Recursive Language Models (RLM's), stelde voor dat modellen hun eigen context actief moeten beheren via symbolische recursie (bijvoorbeeld het schrijven van scripts om hun eigen prompts te chunken en te verwerken). Hoewel RLM's de levensvatbaarheid van actief contextbeheer aantoonden, erven ze de stochastiek van het model: een geheugenstrategie die in één uitvoering werkt, kan in de volgende falen. Bovendien introduceert het omhullen van elke interactie in een recursief raamwerk latentie en kosten ("kort-contextstraf") voor taken die binnen standaardvensters passen. Er is een spanning tussen de expressiviteit van door het model gegenereerde besturingsflow en de betrouwbaarheid die vereist is voor productiesystemen.

Methodologie: Verliesvrij Contextbeheer (LCM)

LCM stelt een deterministische, architectuurcentrische alternatief voor de modelcentrische aanpak van RLM voor. In plaats van het model te vragen geheugenstrategieën te bedenken, verlegt LCM de last van geheugenarchitectuur naar de engine, en biedt een deterministische, database-gedragen infrastructuur. Het systeem is gebouwd op twee pijlers: Recursieve Contextcompressie en Recursieve Taakpartitie.

1. Dual-State Geheugenarchitectuur

LCM zorgt voor verliesvrije herwinbaarheid via een dual-state ontwerp:

• De Onveranderlijke Opslag: Een persistente, transactionele opslag (bijvoorbeeld PostgreSQL) waar elke gebruikersbericht, assistentrespons en tool-resultaat verbatim wordt opgeslagen en nooit wordt gewijzigd. Dit is de bron van waarheid.
• De Actieve Context: Het venster dat bij elke beurt naar de LLM wordt verzonden, samengesteld uit recente ruwe berichten en vooraf berekende samenvattingsknooppunten.

Samenvattingsknooppunten fungeren als gematerialiseerde weergaven die zijn afgeleid van oudere berichten via LLM-samenvatting. Cruciaal is dat het systeem "verliesvrije pointers" behoudt naar de originele data. Als een samenvatting ontoereikend is, stelt de lcm_expand-tool de agent in staat om de originele inhoud verbatim op te halen. Om contextoverstroming te voorkomen, is lcm_expand beperkt tot subtaken, terwijl de hoofdinteractielus alleen samenvattingen observeert.

2. Hiërarchische DAG en Besturingslus

De kerngegevensstructuur is een Directed Acyclic Graph (DAG) van samenvattingen. Naarmate de actieve context vol raakt, worden oudere berichten gecomprimeerd tot samenvattingsknooppunten terwijl de originalen worden bewaard.

• Deterministische Besturingslus: De engine beheert compressie met behulp van zachte ($\tau_{soft}$) en harde ($\tau_{hard}$) tokendrempels.
• Zero-Cost Continuïteit: Onder $\tau_{soft}$ vindt geen samenvatting plaats; het systeem fungeert als een passieve logger, zonder overhead. Compressie wordt asynchroon geactiveerd wanneer drempels worden overschreden, waarbij samenvattingen tussen LLM-beurten in de context worden ingewisseld.
• Drie-niveau Escalatie: Om convergentie te garanderen en "compressiefalen" te voorkomen (waarbij een samenvatting langer is dan de invoer), hanteert LCM een strikt escalatieprotocol:
  1. Normaal: LLM-samenvatting met behoud van details.
  2. Agressief: LLM-samenvatting in opsommingstekens met verlaagde token-doelen.
  3. Deterministische Fallback: Een niet-LLM truncatie naar een vaste tokenlimiet (bijvoorbeeld 512 tokens).

3. Behandeling van Grote Bestanden

Voor bestanden die de contextlimieten overschrijden (bijvoorbeeld grote logs of datasets), laadt LCM niet de volledige inhoud. In plaats daarvan slaat het een referentie (pad, ID) en een vooraf berekende Verkenningssamenvatting op. Deze samenvatting wordt gegenereerd door een typebewuste dispatcher (schema-extractie voor gestructureerde data, structurele analyse voor code, LLM-samenvatting voor tekst), waardoor het model kan redeneren over het bestand zonder het te laden. Bestands-ID's worden doorgegeven via de samenvattings-DAG, zodat het model bewust blijft van tegengekomen bestanden, zelfs na meerdere rondes van compressie.

4. Operator-niveau Recursie

LCM vervangt door het model geschreven lussen door door de engine beheerde primitieven:

• LLM-Map: Verwerkt een lijst van items parallel via stateless LLM-aanroepen (bijvoorbeeld classificatie, extractie).
• Agentic-Map: Start volledige sub-agent-sessies voor elk item, geschikt voor meerstapsredenering of tool-gebruik.
• Garanties: De engine behandelt iteratie, concurrentie, herhalingen en schema-validatie. Uitvoer wordt opgeslagen in externe JSONL-bestanden, wat contextvervuiling voorkomt.
• Scope-Reductie Invariant: Om oneindige delegatielussen te voorkomen, moet een sub-agent declareren welk werk het behoudt versus wat het delegeert. Als een agent probeert zijn volledige verantwoordelijkheid te delegeren, verwerpt de engine de aanroep. Deze structurele garantie zorgt voor terminatie zonder willekeurige dieptelimieten.

Belangrijkste Bijdragen

1. Architectuurverschuiving: LCM verplaatst contextbeheer van een stochastisch, door het model gegenereerd proces (RLM) naar een deterministisch, door de engine beheerd proces. Dit weerspiegelt de historische verschuiving van onbeperkte GOTO-statements naar gestructureerde besturingsflow in programmeertalen.
2. Verliesvrije Herwinbaarheid: In tegenstelling tot RAG of schuifvensters, garandeert LCM dat elke vorige staat verbatim kan worden hersteld via de onveranderlijke opslag, ongeacht hoe vaak de context is gecomprimeerd.
3. Zero-Cost Continuïteit: De architectuur brengt geen latentie- of kostenoverhead met zich mee voor korte taken die binnen het native contextvenster passen, waarmee een belangrijke inefficiëntie in recursieve raamwerken wordt aangepakt.
4. Deterministische Convergentie: Het drie-niveau escalatieprotocol en de scope-reductie invariant bieden wiskundige garanties tegen respectievelijk compressiefalen en oneindige recursie.

Resultaten

De auteurs evalueerden LCM (geïmplementeerd in de Volt agent) tegen Claude Code (v2.1.4) en ruwe Opus 4.6 op de OOLONG benchmark (specifiek de trec_coarse split), waarbij contextlengtes van 8K tot 1M tokens werden getest.

• Prestaties: Volt (LCM) behaalde een gemiddelde absolute score van 74,8, wat 4,5 punten beter is dan Claude Code's 70,3.
• Contextlengte-gevoeligheid:
  • < 32K tokens: Volt en Claude Code presteerden vergelijkbaar, waarbij Claude Code bij kortere lengtes een lichte voorsprong had.
  • > 32K tokens: Volt presteerde consequent beter dan Claude Code. De kloof werd aanzienlijk groter in het ultra-lange regime:
    • Bij 256K tokens: Volt had een voorsprong van 10,0 punten.
    • Bij 512K tokens: Volt had een voorsprong van 12,6 punten.
    • Bij 1M tokens: Volt had een voorsprong van 4,3 punten.
• Baseline Degradatie: Ruwe Opus 4.6 zonder raamwerk vertoonde een steile degradatie na 65K tokens, met een score onder de 20 bij de grootste lengtes.
• Mechanisme: Het prestatievoordeel wordt toegeschreven aan het gebruik van LLM-Map door LCM voor parallelle aggregatie, wat contextverzadiging voorkomt. Daarentegen vertrouwt Claude Code op het model om chunking-strategieën te bedenken, wat foutvariatie en cognitieve belasting introduceert naarmate de context groeit.

Betekenis en Claims

Het paper stelt dat LCM een rechtvaardiging en uitbreiding is van het recursieve paradigma dat door RLM's werd gepionierd. Het toont aan dat recursieve contextmanipulatie niet alleen conventionele LLM's, maar ook geavanceerde coderingsagenten met native bestandssysteemtoegang (zoals Claude Code) kan overtreffen.

De auteurs betogen dat LCM een superieure afweging biedt voor productiemilieus:

• Betrouwbaarheid boven Flexibiliteit: Door de maximale flexibiliteit van door het model geschreven lussen op te offeren, wint LCM terminatiegaranties, zero-cost continuïteit en verliesvrije staatsherwinbaarheid.
• Productiehaalbaarheid: De deterministische primitieven maken de directe implementatie van oneindige-contextarchitecturen mogelijk zonder te wachten tot modellen de meta-vaardigheid beheersen om hun eigen geheugen te beheren.
• Complementariteit: De auteurs suggereren dat LCM en RLM niet wederzijds uitsluitend zijn; een toekomstig systeem zou kunnen defaulten naar LCM's gestructureerde operators voor algemene gevallen, terwijl het RLM-stijl symbolische recursie behoudt voor uitzonderlijke taken die maximale flexibiliteit vereisen.

Het paper concludeert dat het "Architectuurcentrische" perspectief (het bieden van gestructureerde primitieven) betrouwbaarheids- en kostenvoordelen oplevert voor productie-aggregatiewerklasten, vooral naarmate contextlengtes groeien buiten de mogelijkheden van huidige ruwe modelvensters.