Think, But Don't Overthink: Reproducing Recursive Language Models

Deze studie toont aan dat het vergroten van de recursiediepte bij Recursive Language Models, ondanks de belofte van onbeperkte context, leidt tot 'overdenken' dat de prestaties op eenvoudige taken verslechtert en de uitvoeringstijd en kosten exponentieel doet stijgen.

De kern

Titel: Denk na, maar niet te veel: Wat gebeurt er als we een AI te diep laten graven?

Stel je voor dat je een enorme bibliotheek hebt, vol met boeken die je nooit eerder hebt gelezen. Je vraagt een slimme assistent (een AI) om één specifiek feitje te vinden in die bibliotheek.

Dit onderzoek kijkt naar een nieuwe manier om die assistent te laten werken, genaamd RLM (Recursive Language Models). De idee is simpel maar slim: in plaats van dat de assistent alle boeken in één keer probeert te lezen (wat te zwaar is), laat je hem een werkplek (een soort digitaal notitieblok) gebruiken. Hij pakt één boek, zoekt erin, schrijft zijn bevindingen op, en roept zichzelf dan weer op om het volgende boek te bekijken.

De onderzoekers wilden weten: wat gebeurt er als we deze assistent niet één keer, maar twee keer laten roepen? Laten we hem dieper laten graven?

Hier is wat ze ontdekten, vertaald in alledaagse taal:

1. Het "Te Diep Graven"-Probleem

De onderzoekers ontdekten een vreemd fenomeen: soms is meer denken slechter dan minder denken.

• De simpele taak (Zoeken in een hoekje):
  Stel je vraagt: "Wat is de naam van de kat op pagina 5?"
  Een normale AI vindt dit in een seconde. Maar als je de AI dwingt om eerst een notitieblok te openen, zichzelf te laten roepen, en dan pas te zoeken, gaat hij in de war. Hij begint te twijfelen, maakt fouten en vergeet zelfs de naam van de kat.

  • Resultaat: De AI wordt slower en slimmer op een simpele vraag. Het is alsof je iemand vraagt om een glas water te halen, maar je hem eerst een uitgebreid plan laat schrijven over hoe je water haalt.

• De moeilijke taak (Een puzzel oplossen):
  Stel je vraagt: "Vergelijk alle 10.000 regels in dit document en geef een samenvatting."
  Hier werkt de methode perfect! De AI pakt stukjes, schrijft ze op, en bouwt zo een antwoord.

  • Resultaat: De AI wordt veel beter. Zonder deze methode zou hij de draad kwijtraken.

2. De "Overdenken"-Valstrik (Diepte 2)

De onderzoekers probeerden de methode nog een stap verder te duwen: in plaats van dat de assistent één keer zichzelf roept, liet hij hem dat twee keer doen. Ze noemen dit "diepte 2".

Dit ging vreselijk mis.

• De "Gedoe"-factor: De assistent begon te twijfelen over zijn eigen twijfel. Hij begon eindeloze lijsten te maken, controleerde zijn eigen antwoorden, en begon zelfs dingen te verzinnen die er niet stonden (hallucinaties).
• De tijd: Een vraag die normaal 3 seconden duurt, duurde nu 5 minuten (en soms zelfs 9 minuten!).
• De kosten: Het kostte honderden keren meer geld om deze vragen te laten beantwoorden.

3. Drie Manieren waarop het misging

De onderzoekers keken naar de fouten en zagen drie grappige maar zorgwekkende patronen:

1. Het Vergeten van de Context:
   De AI vergat wat er in het document stond en begon te praten over wat hij al wist uit zijn hoofd.

   • Voorbeeld: Je vroeg om een verzonnen getal uit een verhaal, en de AI antwoordde met echte natuurkundige formules over atoomkernen. Hij dacht dat hij slim was, maar hij keek niet naar jouw vraag.

2. De "Verkeerde Rol" (Formatfouten):
   De AI verwardde zijn werkplek met het eindresultaat.

   • Voorbeeld: Je vroeg: "Geef me het antwoord." De AI gaf je in plaats daarvan een stukje computercode dat hij in zijn notitieblok had geschreven, in plaats van het antwoord zelf.

3. De "Show" (Eindeloos Redeneren):
   De AI begon een lange, saaie toespraak te houden over hoe hij aan het antwoord kwam, in plaats van het antwoord te geven.

   • Voorbeeld: In plaats van "Het antwoord is 5", schreef hij: "Stap 1: Ik tel de woorden. Stap 2: Ik check de spelling. Stap 3: Ik twijfel..." Dit duurde 12 minuten en leverde niets op.

De Conclusie: "Denk na, maar niet te veel"

De boodschap van dit onderzoek is helder:

• Voor simpele vragen is de standaard AI al snel genoeg. Een extra "denk-methode" maakt het alleen maar trager en foutgevoeliger.
• Voor moeilijke vragen helpt het om de AI een notitieblok te geven (diepte 1).
• Maar als je de AI te veel laat denken (diepte 2), raakt hij in paniek, begint hij te hallucineren en kost het je een fortuin aan tijd en geld.

Kortom: Net als bij mensen geldt voor AI: soms is een snelle, intuïtieve oplossing beter dan een uur lang zitten te piekeren. De kunst is om te weten wanneer je moet stoppen met denken.

Technische samenvatting

Titel: Denk, maar denk niet te veel na: Reproductie van Recursieve Taalmodellen

Auteur: Daren Wang (The Chinese University of Hong Kong)
Datum: Maart 2026

---

1. Probleemstelling

Grote Taalmodellen (LLMs) kampen met beperkingen in hun contextvenster, wat hen belemmert bij het verwerken van zeer lange documenten of "near-infinite" contexten. Het recente "Recursive Language Models" (RLM) framework, voorgesteld door Zhang et al. (2026), biedt een oplossing door prompts uit te laden naar een externe REPL-omgeving (Read-Eval-Print Loop). Hierdoor kan het model de input programmatisch onderzoeken, decomponeren en recursief aanroepen.

Hoewel het originele paper een recursiediepte van 1 (suboproepen fungeren als standaard LLMs) als standaard instelling gebruikte en diepere recursie als toekomstige richting aanwees, is er onduidelijkheid over de schaalbaarheid. De centrale vraag is: Wat is het effect van het vergroten van de recursiediepte (bijv. naar diepte 2) op prestaties, kosten en latentie, en leidt dit tot "overdenken" (overthinking)?

2. Methodologie

De auteur reproduceert en uitbreidt de experimenten van Zhang et al. (2026) met de volgende aanpassingen:

• Modellen: In plaats van gesloten bronmodellen, werden de nieuwste open-source "agentic" modellen gebruikt: DeepSeek v3.2 en Kimi K2.
• Experimentele Opzet:
  • Benchmarks:
    • S-NIAH (Single Needle-In-A-Haystack): Een eenvoudige ophaaltask (O(1) complexiteit) waarbij een specifiek fragment in een grote corpus moet worden gevonden.
    • OOLONG: Een complexe redeneertask (O(N) complexiteit) die semantische aggregatie en transformatie van bijna alle dataset-items vereist.
  • Vergelijking: Er werden drie configuraties getest:
    1. Pure LLM (geen RLM).
    2. RLM met recursiediepte = 1.
    3. RLM met recursiediepte = 2 (nieuwe toevoeging).
  • Data: Een gefilterde subset van 20 samples per conditie (om API-kosten te beheersen) van de RULER en OOLongBench datasets.
  • Infrastructuur: Experiments uitgevoerd op een lokale laptop (macOS, CPU), waarbij de zware berekening via API's werd uitgevoerd.

3. Belangrijkste Bevindingen en Resultaten

De resultaten tonen een duidelijke "Think, But Don't Overthink" trade-off aan:

A. Paradoxale Verslechtering bij Eenvoudige Taken (S-NIAH)

• Pure LLMs: Bereikten 100% nauwkeurigheid.
• RLM (Diepte 1 & 2): De prestaties daalden drastisch.
  • DeepSeek v3.2 daalde van 100% naar 85% (diepte 1) en vervolgens naar 70% (diepte 2).
  • Kimi K2 daalde van 100% naar 90%.
• Conclusie: Het forceren van een model in een programmatieke REPL-omgeving voor eenvoudige string-matching taken introduceert onnodige cognitieve last, waardoor het model "over-engineert" en fouten maakt.

B. Het "Overdenken"-Effect bij Complexe Redenering (OOLONG)

• RLM (Diepte 1): Biedt een enorme verbetering voor modellen die moeite hebben met lange contexten. DeepSeek v3.2 steeg van 0,0% naar 42,1% nauwkeurigheid.
• RLM (Diepte 2): Verdere recursie leidde tot een daling van de prestaties.
  • DeepSeek v3.2 daalde van 42,1% (diepte 1) naar 33,7% (diepte 2).
  • Kimi K2, dat van nature al sterk was (86,6%), zakte naar 55,0% bij diepte 2.
• Conclusie: Diepere recursie zorgt ervoor dat sub-modellen chaotische suboproepen genereren, wat leidt tot formatfouten, redundante lussen en taalfalen.

C. Operationele Overhead: Tijd, Tokens en Kosten

De studie kwantificeerde de operationele kosten, wat een kritiek punt is voor industriële toepassing:

• Latentie: Er is een exponentiële explosie in uitvoeringstijd.
  • Voor DeepSeek v3.2 op S-NIAH: van 3,6 seconden (Pure LLM) naar 89,3 seconden (Diepte 1) en 344,5 seconden (Diepte 2).
  • Kimi K2 bereikte bij diepte 2 zelfs 545,5 seconden per query.
• Token Kosten: De kosten stijgen met ordes van grootte bij het activeren van RLM.
• Token Plateau: Opmerkelijk genoeg stabiliseerde of daalde het tokengebruik soms bij diepte 2, wat wijst op modellen die vastlopen in formatfouten of eindeloze lussen voordat ze veel tokens verbruiken, maar wel veel tijd kosten.

4. Kwalitatieve Analyse van Foutmodi

De auteur identificeerde drie specifieke foutmodi die optreden bij diepere recursie:

1. Parametrische Hallucinatie: Het model verliest de context-ankering en hallucineert echte wereldkennis (bijv. nucleaire magische getallen) in plaats van de tekst te doorzoeken.
2. Format Collapse in REPL: Het model verwart de REPL-omgeving met de eindoutput en retourneert ruwe Python-code (bijv. print(f"Answer: ...")) in plaats van de gevraagde string.
3. Performatief Redeneren: Het model blijft eindeloos sub-oproepen genereren en verifiëren (bijv. stap-voor-stap essays schrijven) zonder de taak te voltooien, wat leidt tot extreme latentie zonder proportionele token-uitbreiding.

5. Bijdrage en Significatie

• Reproductie en Uitbreiding: Dit paper bevestigt de oorspronkelijke bevindingen van RLM maar voegt cruciaal inzicht toe door de limiet van recursiediepte (diepte 2) te testen.
• Waarschuwing voor Industriële Toepassing: Hoewel RLM theoretisch de contextvensters van kleinere modellen kan uitbreiden, maakt de huidige implementatie met diepe recursie het onpraktisch voor industriële schaal. De enorme latentie, explosieve API-kosten en het risico op "overdenken" wegen niet op tegen de voordelen, zeker niet gezien de capaciteiten van moderne frontier-modellen (zoals Kimi K2) die lange contexten al natief kunnen verwerken.
• Toekomstige Richting: De studie pleit voor het ontwikkelen van betere stopmechanismen binnen REPL-omgevingen om redundante lussen te voorkomen, en voor het trainen van native RLM-modellen die inherent zijn afgestemd op programmatieke omgevingen zonder formatfouten of hallucinaties.

Kernboodschap: Recursie is een krachtig hulpmiddel voor complexe redeneertaken (diepte 1), maar het "overdenken" door diepere recursie (diepte 2) breekt de modellen, verhoogt de kosten exponentieel en verslechtert de prestaties, zelfs bij modellen die van nature sterk zijn.