Net wanneer we gewend zijn aan termen als RAG (Retrieval-Augmented Generation) en Context Windows van miljoenen tokens, komt er weer iets nieuws aan. Recursive Language Models, ofwel RLMs.

Als je regelmatig met Large Language Models (LLM’s) werkt, ben je waarschijnlijk bekend met de frustratie van lange conversaties. Je begint sterk, maar naarmate de chatgeschiedenis groeit, lijkt het model vergeetachtig of zelfs minder intelligent te worden. Dit fenomeen, bekend als context rot, is een van de grootste obstakels voor het bouwen van echt autonome AI-agenten die complexe taken over lange periodes kunnen uitvoeren. Recursive Language Models bieden hier een fascinerende, technische oplossing voor. In deze diepgaande post duiken we in wat ze zijn, wat ze zo anders maakt en waarom ze wel eens het paradigma van 2026 zouden kunnen worden.

Wat zijn Recursive Language Models (RLMs)?

In de kern is een Recursive Language Model een slimme inferentie-strategie. In plaats van een LLM simpelweg te voeden met een enorme lap tekst (de prompt) en te hopen dat het model alles onthoudt, benadert een RLM de input op een andere manier. Het behandelt de context niet als een statische stroom van tokens die in één keer verwerkt moet worden, maar als een variabele in een externe omgeving.

Stel je voor dat je een programmeur bent die een gigantisch logbestand van 100.000 regels moet analyseren. Je gaat dat bestand niet regel voor regel lezen van begin tot eind. Nee, je opent een terminal, je gebruikt commando’s zoals `grep` om te zoeken naar specifieke patronen, je leest kleine stukjes rondom de interessante punten, en je noteert je bevindingen. Dit is precies wat een RLM doet.

De rol van de REPL-omgeving

Een RLM plaatst de input-context (bijvoorbeeld een heel boek, een enorme codebase of duizenden documenten) in een Python REPL-omgeving (Read-Eval-Print Loop). Het taalmodel zelf ziet de tekst in eerste instantie niet eens. Het weet alleen, er is een variabele x en die bevat heel veel data.

Vervolgens kan het model code schrijven om interactie te hebben met die data. Het kan:

  • De lengte van de tekst opvragen.
  • Zoeken naar specifieke trefwoorden.
  • De tekst opdelen in kleinere stukken (chunks).
  • En het recursieve aspect, zichzelf of andere LLM’s aanroepen om die kleinere stukjes te analyseren.

Dit proces stelt het model in staat om taken uit te voeren op input van in theorie onbeperkte lengte, zonder dat het model zelf een gigantisch context window nodig heeft. Het is een vorm van context folding: het model bewerkt de enorme hoeveelheid informatie tot behapbare brokken en verwerkt deze stap voor stap.

Het probleem, context rot en de limieten van aandacht

Om de kracht van RLMs te begrijpen, moeten we eerst kijken naar het probleem dat ze oplossen. Moderne modellen zoals GPT, Claude of Gemini hebben indrukwekkende context windows. Je kunt er hele boeken in uploaden. Maar er is een verschil tussen data kunnen invoeren en die data effectief gebruiken.

Onderzoekers spreken over context rot. Dit fenomeen beschrijft hoe de prestaties van een model degraderen naarmate de context langer wordt. Het is niet alleen dat het model dingen vergeet; het redeneervermogen zelf lijkt achteruit te gaan. Het model wordt dommer naarmate de conversatie vordert of de input groter wordt.

Dit komt doordat het aandachtsmechanisme (attention mechanism) in Transformers kwadratisch schaalt en moeite heeft om focus te behouden. Zelfs als een model technisch gezien 1 miljoen tokens aankan, betekent dit niet dat het de speld in die hooiberg even goed kan vinden als in een tekst van 1000 tokens. Vooral bij taken die een hoge informatiedichtheid hebben, waar bijna elke zin belangrijk is, falen traditionele modellen vaak bij veel input.

Wat maakt RLMs anders dan bestaande technieken?

Doen we dit niet al met AI-agenten of RAG? Het antwoord is ja en nee. RLMs verschillen op fundamentele wijze van de huidige standaarden.

Verschil met RAG (Retrieval-Augmented Generation)

Bij RAG wordt een database doorzocht om relevante stukjes tekst te vinden, die vervolgens aan de prompt worden toegevoegd. Dit werkt goed voor feitelijke vragen (Wat is de hoofdstad van Peru?), maar faalt vaak bij complexe redeneertaken over een hele dataset (Wat is de algemene trend in deze 500 financiële rapporten en hoe verhoudt die zich tot de strategie van 2020?). RAG mist het overzicht. Een RLM daarentegen heeft toegang tot de volledige context via de code-omgeving en kan strategisch beslissen welke delen het moet lezen, samenvatten of vergelijken.

Verschil met traditionele Agenten (zoals AutoGPT)

Veel agent-systemen gebruiken een loop. Ze voeren een taak uit, beijken het resultaat en gaan door. Vaak vertrouwen ze op het samenvatten van de geschiedenis om binnen de limieten te blijven. Dit leidt tot verlies van informatie (lossy compression). Een RLM vat niet zomaar samen, het delegeert. Het model kan beslissen dat de sectie te groot is en start een sub-LLM (een kopie) om alleen een specifiek stukje te analyseren en het antwoord te geven. De hoofd-LLM (root model) blijft gefocust, terwijl de sub-LLM’s het zware werk doen.

Context als variabele, niet als prompt

Dit is het meest cruciale verschil. In een normale LLM-call is de input tekst. In een RLM is de input een object in het geheugen van een computerprogramma. Het model wordt een programmeur die de data manipuleert in plaats van een lezer die de data probeert te onthouden. Dit sluit aan bij de bitter lesson van AI-onderzoek. Systemen die gebruikmaken van algemene rekenkracht en zoekmethodes winnen uiteindelijk altijd van systemen die vertrouwen op menselijke heuristiek.

Hoe werkt het in de praktijk?

Laten we eens kijken hoe een RLM een complexe taak aanpakt. Stel, we geven het model de opdracht: “Vind in deze dataset van 100.000 regels alle gebruikers die zowel in 2023 als in 2024 een aankoop hebben gedaan, en bereken hun gemiddelde uitgaven.”

Een standaard LLM zou proberen de hele dataset in zijn context te laden. Dit past waarschijnlijk niet in de context, is te duur of het model begint te hallucineren of loopt vast. Een RLM pakt dit anders aan:

  1. Initialisatie: De Root-LLM start op. Hij ziet geen data, maar ziet wel: `dataset_length = 100.000 lines`.
  2. Verkenning (Peeking): Het model schrijft Python-code om de eerste 10 regels te lezen. Zo leert het de structuur van de data (CSV, JSON, etc.).
  3. Strategie bepalen: Het model beseft dat het te veel data is om in één keer te lezen. Het besluit de data op te splitsen in blokken (chunks) van 5.000 regels.
  4. Recursie: Het model schrijft een loop. Voor elk blok van 5.000 regels roept het een sub-LLM aan met de specifieke instructie: “Extraheer gebruikers en bedragen uit dit blok”. Dit is de vernieuwing.
  5. Aggregatie: De sub-LLM’s doen hun werk parallel of sequentieel en sturen gestructureerde data terug naar de variabele in de REPL-omgeving.
  6. Final Answer: De Root-LLM gebruikt Python om de resultaten van alle sub-LLM’s samen te voegen, de gemiddelden te berekenen en het eindantwoord te formuleren.

Het mooie hiervan is dat geen enkel individueel model de volledige context hoeft te zien. De Root-LLM ziet alleen de code en de samengevatte resultaten. De sub-LLM’s zien alleen hun kleine stukje data. Hierdoor wordt context rot volledig omzeild.

Voor welke taken zijn RLMs geschikt?

Uit experimenten, waaronder die met de OOLONG benchmark en Deep Research taken, blijkt dat RLMs uitblinken in specifieke scenario’s waar standaard modellen falen.

Deep Research en Informatie Aggregatie

Wanneer het antwoord op een vraag verspreid ligt over tientallen of honderden documenten, is een RLM superieur. Denk aan juridisch onderzoek (“Zoek in deze 5.000 contracten naar clausules over overmacht en vergelijk ze”) of wetenschappelijke reviews.

Extreem lange contexten (10M+ tokens)

Er zijn situaties waarin de context simpelweg te groot is voor elk bestaand model. Denk aan het analyseren van de volledige geschiedenis van een groot softwareproject of het verwerken van genetische sequenties. RLMs hebben aangetoond dat ze kunnen schalen naar 10 miljoen tokens of meer zonder prestatieverlies, simpelweg door de verdeel en heers strategie toe te passen.

Complexe Needle-in-a-Haystack taken

Standaard modellen zijn goed in het vinden van één specifiek feitje in een lange tekst. Maar wat als je moet zoeken naar alle zinnen die een impliciete verwijzing maken naar een gebeurtenis uit hoofdstuk 1? Dit vereist redeneren over de hele tekst. RLMs kunnen de tekst scannen, potentiële kandidaten filteren met code (bijvoorbeeld regex) en vervolgens recursief inzoomen op de relevante delen om de semantische betekenis te verifiëren.

Codebase Management

Voor softwareontwikkelaars is dit krachtig. Een RLM kan door een hele repository navigeren, bestanden openen, afhankelijkheden controleren en wijzigingen voorstellen, precies zoals een menselijke ontwikkelaar dat zou doen in een IDE. Het model leest niet de hele codebase, maar navigeert erdoorheen.

Resultaten

De resultaten in de eerste papers over RLMs zijn veelbelovend. Op de OOLONG benchmark, die specifiek is ontworpen om modellen te testen op taken met een hoge informatiedichtheid, presteerde een RLM-setup met een kleiner model (GPT-5-mini) meer dan twee keer zo goed als het grotere basismodel (GPT-5). Dit is contra-intuïtief. Een dommer model dat slim gebruikmaakt van recursie en tools, verslaat een slimmer model dat probeert alles in één keer te bevatten.

Nog opvallender is de kostenefficiëntie. Omdat het model selectief leest en taken delegeert, worden er minder tokens verbruikt dan wanneer je een gigantische prompt in één keer naar een duur frontier-model stuurt. Hier is beter ook goedkoper.

De toekomst

Onderzoekers bij laboratoria zoals Prime Intellect en MIT suggereren dat RLMs wel eens de volgende grote stap kunnen zijn na Chain-of-Thought (CoT) en agent-modellen. Waar we nu nog vaak handmatig prompts optimaliseren (prompt engineering), gaan we toe naar een wereld waar het model zelf leert hoe het zijn context moet managen.

Het idee is dat toekomstige modellen niet alleen getraind worden om het volgende woord te voorspellen, maar specifiek getraind worden om te werken binnen een RLM-architectuur. Ze leren dan tijdens hun training al wanneer ze moeten stoppen met lezen, wanneer ze code moeten schrijven en wanneer ze een sub-taak moeten delegeren. Dit wordt inference-time scaling genoemd, het vergroten van de rekenkracht tijdens het nadenken, in plaats van alleen tijdens het trainen.

Er zijn natuurlijk nog uitdagingen. De huidige implementaties zijn soms traag omdat de requests sequentieel (na elkaar) gebeuren in plaats van asynchroon. Ook vereist het schrijven van foutloze code door het model een zekere basisintelligentie; kleinere open-source modellen worstelen hier soms nog mee. Maar de richting is duidelijk.

Conclusie

Recursive Language Models lossen het probleem van context rot op door de verdeel en heers strategie,na te bootsen via code en recursie. In plaats van modellen simpelweg groter te maken, maken RLMs ze slimmer in hoe ze met informatie omgaan.

Terwijl de modellen zelf krachtiger worden, worden de architecturen eromheen, zoals RLMs, minstens zo belangrijk. Het gaat niet langer over hoe slim het model is, maar hoe slim gaat het model om met wat het weet?. Op die vraag geven Recursive Language Models een heel overtuigend antwoord.