CRITIC: Waarom LLM-zelfcorrectie feedback van externe tools vereist

Ik las CRITIC (Gou et al., ICLR 2024) terwijl ik nadacht over wat er gebeurt nadat een financiële agent een fout maakt. Reflexion vertelde ons dat agents kunnen leren van fouten over verschillende episodes. CRITIC stelt een scherpere vraag: kan een LLM zijn eigen fouten vangen en herstellen binnen een enkele generatieronde — en zo ja, wat heeft het daar precies voor nodig?

Het artikel

CRITIC introduceert een raamwerk waarin een taalmodel een initiële output genereert, en vervolgens een 'verifieer-dan-corrigeer'-lus doorloopt met behulp van externe tools — een zoek-API voor feitelijke claims, een Python-interpreter voor code en rekenwerk, en een toxiciteitsclassificator voor contentmoderatie. De lus draait een vast aantal iteraties (het artikel rapporteert effectieve resultaten in ongeveer drie correcties), wat resulteert in een verfijnde output die de auteurs evalueren op open vragen (TriviaQA, AmbigNQ, HotpotQA), wiskundige programmasynthese en toxiciteitsreductie.

De centrale bewering is niet dat LLM's uit zichzelf kunnen corrigeren. Het is bijna het tegenovergestelde: de waarde van CRITIC komt voort uit het verankeren van de kritiek in een extern signaal dat het model niet kan vervalsen. Zonder de zoek-API krimpen de QA-verbeteringen tot bijna nul of keren ze zelfs om. Het raamwerk werkt omdat de tool het model iets vertelt dat het oprecht niet wist, niet omdat het model een betrouwbare zelfcontroleur wordt.

Belangrijkste ideeën

• Toegepast op ChatGPT behaalt CRITIC een verbetering van 7,7 in F1-score gemiddeld over drie open-domein QA-taken en een absolute winst van 7,0 procentpunten op drie wiskundige redeneerbenchmarks.
• Toxiciteitsreductie is het meest opvallende resultaat: een afname van 79,2% in de kans op toxiciteit op de geëvalueerde dataset.
• Het verwijderen van de zoek-API zorgt ervoor dat de QA-prestaties stagneren of verslechteren — het intrinsieke zelfkritische vermogen van het model is nagenoeg nutteloos voor feitelijke taken.
• De lus convergeert snel: drie correctierondes vangen het grootste deel van de winst op, met afnemende meeropbrengsten daarna.
• Het raamwerk is model-agnostisch en vereist geen fine-tuning; het werkt op black-box API's zoals Text-Davinci-003 en ChatGPT.
• CRITIC presteert beter dan self-consistency (meerderheidsstemmen over meerdere samples) op de meeste taken, wat significant is omdat self-consistency geen tool-kosten per stap heeft.

Wat standhoudt — en wat niet

Het empirische kernresultaat is solide: feedback van externe tools verbetert de output aanzienlijk, en de ablatie waarbij de zoek-API wordt verwijderd, is vernietigend voor voorstanders van naïeve zelfcorrectie. Het artikel is ook eerlijk over het mechanisme — de winst komt van de tool, niet van een opkomend metacognitief vermogen.

Wat ik onvoldoende onderzocht vind, is de taxonomie van foutmodi. Wanneer genereert het model een slechte kritiek die het verder van het juiste antwoord afleidt? Het artikel rapporteert gemiddelde prestaties, maar de variantie over taken en vraagtypen zou enorm belangrijk zijn voor implementatie. In een financiële context is de slechtste uitkomst niet "geen verbetering" — het is een aannemelijk klinkende correctie die een nieuwe fout introduceert.

De keuze om te beperken tot drie iteraties wordt ook gepresenteerd als praktisch gemak in plaats van een principieel stopcriterium. Drie rondes kunnen werken voor TriviaQA waar er een ground-truth antwoord is om naartoe te convergeren. In een domein als grootboekreconciliatie, waar het "juiste" antwoord redenering over meerdere documenten en domeinkennis vereist, is het niet vanzelfsprekend dat drie tool-calls volstaan — of dat een algemene zoek-API überhaupt het juiste verificatiesignaal levert.

Het begeleidende ICLR 2024-artikel "Large Language Models Cannot Self-Correct Reasoning Yet" (Huang et al., arXiv:2310.01798) bevestigt de bevinding van CRITIC vanuit de andere kant: zonder externe feedback verslechtert zelfcorrectie de nauwkeurigheid van het redeneren betrouwbaar. Deze twee artikelen vormen samen een coherent beeld — het vermogen dat mensen "zelfcorrectie" noemden, is meestal verfijning gedreven door externe feedback, en dat onderscheid is essentieel.

Waarom dit belangrijk is voor financiële AI

De CRITIC-lus sluit natuurlijk aan op het veiligheidsprobleem bij het terugschrijven in Beancount-agents. Op dit moment, wanneer een LLM-agent een journaalpost voorstelt — bijvoorbeeld door een transactie te categoriseren of een uitgave te splitsen — is er geen principiële manier voor de agent om zijn eigen output te verifiëren voordat deze naar de schijf wordt geschreven. De architectuur van CRITIC suggereert een concreet patroon: genereer een kandidaat-boeking, voer vervolgens een verificatie uit tegen een tool (een saldo-controlefunctie, een rules-engine, een duplicaatdetector) en gebruik de output van de tool om een revisie aan te sturen voordat de schrijfactie plaatsvindt.

Het resultaat over toxiciteit is een analogie die ik nuttig vind om te herhalen: een vermindering van 79,2% in beleidsschendingen komt niet voort uit het model dat de regels internaliseert — het komt voort uit een classificator die schendingen terugkoppelt aan het model. Voor een Beancount-grootboek zou het equivalent een regel-checker zijn die dubbel getelde transacties of categorie-schendingen markeert, en dat signaal invoert in de revisieronde van de agent. De agent hoeft niet zelfstandig te weten dat de regels zijn overtreden; hij heeft het signaal van de tool nodig.

De kritieke beperking voor financiën is de afhankelijkheid van de zoek-API. Financiële agents hebben verificatietools nodig die domeinspecifiek zijn: integriteitscontroles van rekeningsaldi, validaties van het rekeningschema, opzoeken van belastingregels. Een generieke webzoekopdracht zal waarschijnlijk geen verkeerd geclassificeerde uitgave opmerken. Het bouwen van de juiste tool-laag voor correctie in CRITIC-stijl binnen de boekhouding is waar het echte technische werk zit — en het artikel gaat helemaal niet in op het ontwerp van domeinspecifieke tools.

Wat je nu kunt lezen

• "Large Language Models Cannot Self-Correct Reasoning Yet" (Huang et al., 2023, arXiv:2310.01798) — het directe empirische argument dat intrinsieke zelfcorrectie faalt; zou samen met CRITIC gelezen moeten worden omdat ze hetzelfde mechanisme vanuit tegengestelde richtingen belichten.
• "Tree of Thoughts: Deliberate Problem Solving with Large Language Models" (Yao et al., NeurIPS 2023, arXiv:2305.10601) — breidt het idee van een enkel pad van kritiek-en-correctie uit naar een zoekboom over tussenstappen; relevant voor reconciliatie in meerdere stappen waarbij de agent moet verkennen en teruggaan.
• "ToolBench: Facilitating Large Language Models in Mastering 16000+ Real-world APIs" (Qin et al., 2023, arXiv:2307.16789) — onderzoekt hoe agents leren om tool-calls te selecteren en te koppelen, wat het stroomopwaartse probleem is dat CRITIC als vanzelfsprekend beschouwt.