Technische Samenvatting: Recursieve Taalmodellen (RLMs)

Probleemstelling

Frontier grote taalmodellen (LLMs) staan voor aanzienlijke beperkingen bij het verwerken van willekeurig lange prompts. Zelfs binnen de limieten van hun contextvenster vertonen deze modellen "contextrot", waarbij de prestaties sterk achteruitgaan naarmate de promptlengte en taakcomplexiteit toenemen. Bestaande benaderingen voor verwerking van lange contexten vallen over het algemeen in twee categorieën:

1. Architectuur-/Trainingswijzigingen: Het hertrainen van modellen om langere sequenties te verwerken (bijvoorbeeld via lineaire aandacht of toestandruimtes).
2. Inferentie-tijd Scaffolds: Methoden zoals contextcompactering (samenvatting) of ophaalagenten. Compactering is echter vaak ontoereikend voor taken die een dichte toegang tot de volledige prompt vereisen, omdat het ervan uitgaat dat vroege details veilig vergeten kunnen worden. Benaderingen met ophalen en delegering aan sub-agenten worden vaak gehandicapt door de beperkte outputlengtes van het onderliggende model of het gebrek aan programmeerbare controle over recursie.

De auteurs stellen dat het schalen van de contextgrootte met ordes van grootte een paradigma-shift vereist waarbij de prompt niet wordt behandeld als een statische invoer voor een neuronaal netwerk, maar als een dynamisch onderdeel van een externe omgeving waarmee het model symbolisch kan interageren.

Methodologie: Recursieve Taalmodellen (RLMs)

Het artikel introduceert Recursieve Taalmodellen (RLMs), een algemeen inferentieparadigma waarbij de gebruikersprompt wordt uitbesteed aan een persistente externe omgeving (specifiek een Python REPL) in plaats van deze direct in het contextvenster van het model te voeden.

Kernmechanisme

1. Omgevingsinitialisatie: Gegeven een prompt $P$, initialiseert de RLM een Read-Eval-Print Loop (REPL)-omgeving waarin $P$ wordt opgeslagen als een stringvariabele.
2. Symbolische Interactie: Het basale LLM ($M$) wordt gevraagd code te schrijven binnen deze REPL. Het krijgt metadata over $P$ (bijvoorbeeld lengte), maar ontvangt de volledige tekst niet in zijn contextvenster.
3. Programmeerbare Decompositie: Het LLM schrijft code om $P$ te inspecteren, te decomponeren en te transformeren. Cruciaal is dat het programmatisch een sub-LLM (of sub-RLM) kan aanroepen op specifieke slices of chunks van de promptvariabele.
4. Recursieve Executie: Het systeem voert de gegenereerde code uit. Tussenresultaten worden opgeslagen in REPL-variabelen. Het LLM observeert iteratief de output van deze uitvoeringen (afgekapt om in het contextvenster te passen) en genereert verdere code totdat een definitief antwoord is geproduceerd.
5. Beëindiging: Het proces stopt wanneer het LLM een Final-variabele instelt in de REPL, die als reactie wordt teruggegeven.

Belangrijke Ontwerpkiezen

De auteurs onderscheiden RLMs van "ineffectieve" scaffolds (Algoritme 2 in het artikel) door drie kritieke ontwerpkiezen:

• Symbolische Handvatten: De prompt is een variabele in de omgeving, niet tekst in het contextvenster, wat manipulatie mogelijk maakt zonder kopiëren.
• Indirecte Output: Het model genereert het definitieve antwoord niet direct via een "Finish"-actie (wat beperkt zou zijn door de contextvenstergrootte), maar construeert het via variabelen in de REPL.
• Symbolische Recursie: De code die in de omgeving draait, kan het LLM programmatisch aanroepen op transformaties van $P$ binnen loops, waardoor $\Omega(|P|)$ of zelfs $\Omega(|P|^2)$ semantisch werk mogelijk is, in plaats van slechts het verbaal maken van een paar subtaken.

Experimentele Opstelling

De auteurs evalueerden RLMs met behulp van frontier gesloten modellen (GPT-5) en open modellen (Qwen3-Coder-480B-A35B) over vier taken met variërende complexiteitsschalen:

• S-NIAH (Single Needle-in-a-Haystack): Constante complexiteit ten opzichte van de invoerlengte.
• BrowseComp-Plus: Multi-hop QA over 1.000 documenten (lineaire complexiteit).
• OOLONG: Semantische labeling en aggregatie van een dataset (lineaire complexiteit).
• OOLONG-Pairs: Aggregatie van paren chunks om antwoorden te construeren (kwadratische complexiteit).
• LongBench-v2 CodeQA: Begrip van code-repositories.

Basislijnen omvatten directe LLM-aanroepen, CodeAct-agenten (met/zonder sub-aanroepen), agenten voor contextcompactering, ophaalagenten en coderingsagenten (OpenCode, Claude Code).

Belangrijkste Resultaten

• Schalbaarheid: RLMs verwerkten succesvol invoer van meer dan 10 miljoen tokens, ver buiten de contextvensters van de basismodellen (bijvoorbeeld het 272k-limiet van GPT-5).
• Prestatiewinst:
  • Op OOLONG-Pairs (kwadratische complexiteit) bereikten basismodellen een prestatie dicht bij nul ($\le 0,1\%$ F1), terwijl RLMs 58,0% (GPT-5) en 23,1% (Qwen3-Coder) bereikten.
  • Over benchmarks heen presteerden RLMs aanzienlijk beter dan basismodellen en veelvoorkomende scaffolds (bijvoorbeeld +26% mediaan ten opzichte van compactering, +130% ten opzichte van CodeAct met sub-aanroepen op GPT-5).
  • RLMs toonden robuustheid tegen "contextrot", waarbij ze prestaties behielden naarmate de invoerlengte toenam, terwijl de prestaties van basismodellen scherp achteruitgingen.
• Kostenefficiëntie: Inferentiekosten voor RLMs waren vergelijkbaar met of goedkoper dan aanroepen van basismodellen en andere scaffolds, ondanks de overhead van meerdere sub-aanroepen.
• Fine-tuning: Een kleinschalig experiment fine-tuned RLM-Qwen3-8B op 1.000 trajecten gedistilleerd uit een groter model. Dit model presteerde met een mediaan van 28% beter dan de basis Qwen3-8B en benaderde de kwaliteit van vanilla GPT-5 op drie lange-contexttaken, wat aantoont dat RLM-gedrag met minimale data geleerd kan worden.
• Redeneercapaciteiten: Op de LongCoT-mini-benchmark verbeterden RLMs met decompositiehinten de oplossingspercentages met 69,5% ten opzichte van het basismodel, en orchestreerden effectief complexe redeneringsgrafieken.

Betekenis en Claims

Het artikel claimt dat RLMs een nieuwe as van schaling voor taalmodellen vertegenwoordigen, verschillend van het vergroten van modelparameters of contextvenstergroottes. Door de prompt te behandelen als een extern object en symbolische recursie mogelijk te maken, overwinnen RLMs de beperkingen in uitdrukkingskracht van standaard Transformers en bestaande agent-scaffolds.

Belangrijke claims zijn:

1. Taalonafhankelijke Schalbaarheid: RLMs bieden een algemeen raamwerk voor het verwerken van willekeurig lange invoer zonder taakspecifieke engineering.
2. Efficiëntie: Het paradigma maakt dichte verwerking van lange contexten mogelijk tegen kosten die vergelijkbaar zijn met standaard inferentie.
3. Trainbaarheid: De auteurs leveren eerste bewijs dat modellen expliciet getraind kunnen worden om als RLM te handelen, wat suggereert dat "redeneren als RLM" een trainbare capaciteit zou kunnen zijn die de algemene prestaties en efficiëntie verbetert.
4. Beperkingen: De auteurs erkennen huidige beperkingen, waaronder het sequentiële karakter van hun implementatie (wat leidt tot hoge latentie), de broosheid bij het onderscheiden van definitieve antwoorden van gedachten in ongetrainde modellen, en het potentieel voor "exploderende" sub-aanroepkosten als deze niet worden beheerd. Zij merken op dat asynchrone uitvoering en in een zandbak geplaatste REPL's toekomstige richtingen zijn voor optimalisatie.

Het werk concludeert dat RLMs een veelbelovende weg bieden naar algemene taalmodellen die taken op lange termijn kunnen verwerken die tientallen of honderden miljoenen tokens omvatten.