Re4: Scientific Computing Agent with Rewriting, Resolution, Review and Revision

Deze paper introduceert Re4, een nieuw agent-framework dat drie gespecialiseerde taalmodellen (Consultant, Reviewer en Programmer) combineert via een cyclus van herschrijven, oplossen, beoordelen en herzien om betrouwbare en foutloze code voor wetenschappelijke berekeningen te genereren.

De kern

RE4: De Slimme Werkteam voor Wetenschappelijke Rekenproblemen

Stel je voor dat je een heel moeilijk wiskundig probleem hebt, zoals het voorspellen van hoe stromend water zich gedraagt in een turbine, of hoe hitte zich verspreidt in een metalen plaat. In het verleden moest je hiervoor een zeer gespecialiseerde wiskundige of ingenieur inhuren die jarenlang heeft gestudeerd om de juiste code te schrijven.

Deze paper introduceert RE4, een nieuw digitaal "werkteam" dat kunstmatige intelligentie (AI) gebruikt om deze taken volledig zelfstandig op te lossen. Het is alsof je niet één, maar drie slimme experts aan het werk zet die samenwerken om een probleem op te lossen.

Hier is hoe het werkt, vertaald naar alledaagse taal:

1. Het Team: Drie Rollen, Eén Doel

In plaats van één AI die alles probeert te doen (en vaak fouten maakt), heeft RE4 een team van drie verschillende AI's, elk met een specifieke rol:

• De Consultant (De Strategist):

  • Wat hij doet: Stel je voor dat je een vaag idee hebt: "Ik wil weten hoe dit stroomt." De Consultant is de expert die dit vaag idee omzet in een strak plan. Hij denkt na over de wiskundige regels, kiest de beste strategie en legt uit waarom die strategie werkt. Hij zorgt ervoor dat het probleem goed wordt begrepen voordat er überhaupt iets wordt gebouwd.
  • Analogie: Hij is de architect die de blauwdrukken tekent voordat de bouw begint.

• De Programmer (De Bouwer):

  • Wat hij doet: Deze AI neemt het plan van de Consultant en schrijft de daadwerkelijke computercode (in Python). Hij is de timmerman die de blauwdrukken omzet in een huis.
  • Analogie: Hij bouwt het huis, maar zonder de architect of de inspecteur kan hij soms de verkeerde spijkers gebruiken of de muren scheef zetten.

• De Reviewer (De Kwaliteitscontroleur):

  • Wat hij doet: Dit is de echte kracht van RE4. Zodra de Programmer de code heeft geschreven, draait hij hem. De Reviewer kijkt naar de resultaten. Als de code crasht, of als de uitkomsten onzinnig zijn (bijvoorbeeld: "water dat omhoog stroomt in tegengestelde richting"), zegt de Reviewer: "Hé, dit klopt niet! Hier zit een fout." Hij geeft specifieke feedback aan de Programmer om het opnieuw te proberen.
  • Analogie: Hij is de bouwkundig inspecteur die de muren meet en zegt: "Deze muur staat scheef, maak hem recht voordat we doorgaan."

2. Het Proces: De "Herhaal-Lus"

Het magische aan dit systeem is dat het niet stopt bij één poging. Het volgt een cyclus van 4 stappen:

1. Herschrijven: De Consultant maakt het probleem helder.
2. Oplossen: De Programmer bouwt de code.
3. Beoordelen: De Reviewer test de code en vindt fouten.
4. Herzien: De Programmer kijkt naar de feedback van de Reviewer, repareert de fouten en probeert het opnieuw.

Dit proces herhaalt zich totdat de code perfect werkt. Het is alsof je een schrijver bent die een verhaal schrijft, een redacteur die het leest en feedback geeft, en de schrijver die het verhaal herschrijft tot het perfect is.

3. Waarom is dit zo belangrijk?

Vroeger maakten AI's vaak fouten bij wetenschappelijke berekeningen. Ze konden code schrijven die er goed uitzag, maar die in het echt "crashte" of onmogelijke resultaten gaf (zoals een getal dat oneindig groot wordt).

De paper toont aan dat door dit teamwerk en de herhaalde controle:

• De kans dat de code werkt (zonder fouten) enorm stijgt (van ongeveer 60% naar meer dan 80-85%).
• De resultaten veel nauwkeuriger zijn.
• De AI minder "hallucineert" (dus minder onzin produceert).

4. Wat hebben ze getest?

Ze hebben dit systeem laten werken op drie soorten moeilijke taken:

1. Deelvergelijkingen (PDE's): Het simuleren van complexe natuurkundige fenomenen, zoals hoe lucht stroomt rond een vliegtuigvleugel of hoe een schokgolf zich voortplant.
2. Moeilijke Rekenproblemen: Het oplossen van wiskundige systemen die zo instabiel zijn dat normale methoden direct falen (zoals de "Hilbert-matrix").
3. Data-analyse: Het vinden van de onderliggende wetten in experimentele data, bijvoorbeeld om te begrijpen hoe diep een gat (keyhole) ontstaat in metaal tijdens laswerk.

Conclusie

Kortom, RE4 is geen enkele super-AI, maar een slimme samenwerking tussen drie AI's. Door te laten "schrijven, controleren en verbeteren", creëren ze een systeem dat betrouwbaar genoeg is om complexe wetenschappelijke problemen op te lossen zonder dat een mens elke stap hoeft te controleren. Het is een grote stap richting een toekomst waar computers ons helpen de geheimen van de natuurkunde te ontrafelen, zonder dat we zelf de code hoeven te debuggen.

Technische samenvatting

Titel: RE4: Wetenschappelijk Rekenen Agent met Herschrijven, Oplossen, Beoordelen en Herzien

1. Het Probleem

Wetenschappelijk rekenen (scientific computing) is een hoeksteen van moderne wetenschap en engineering, maar het vereist doorgaans diepgaande domeinkennis, geavanceerde algoritmeontwerp en rigoureuze code-implementatie. Hoewel Large Language Models (LLMs) beloftevol zijn voor het genereren van code op basis van natuurlijke taal, staan ze voor twee grote uitdagingen in dit domein:

1. Autonome methodeselectie: LLMs moeten vaak zelfstandig de juiste numerieke methoden kiezen voor specifieke problemen (bijv. het type differentiaalvergelijking bepalen) zonder menselijke tussenkomst.
2. Foutloze code-generatie: Zelfs geavanceerde "redenerende" LLMs (zoals DeepSeek R1 of GPT-4) genereren vaak code met bugs, syntaxisfouten of leiden tot niet-fysische oplossingen (bijv. NaN-waarden), zelfs bij klassieke problemen. Bestaande frameworks missen vaak een gestructureerde manier om feedback van runtime-resultaten te gebruiken voor zelfcorrectie.

2. Methodologie: Het RE4-Agent Framework

De auteurs introduceren een nieuw agent-framework genaamd RE4, dat een logische keten van vier stappen implementeert: Rewriting (Herschrijven), Resolution (Oplossen), Review (Beoordelen) en Revision (Herzien). Dit framework maakt gebruik van een collaboratieve multi-agent architectuur met drie gespecialiseerde rollen, elk uitgevoerd door een LLM:

• Consultant (Adviseur):

  • Functie: Werkt als een wiskundig consultant en numeriek analist.
  • Taak: Herschrijft en breidt de oorspronkelijke, vaak vage probleemomschrijvingen uit door domeinspecifieke kennis te integreren. Het identificeert onderliggende wiskundige uitdagingen en stelt gestructureerde oplossingsstrategieën (bijv. pseudocode) voor.
  • Doel: Het vertalen van natuurlijke taal naar een diepgaand, technisch onderbouwd probleemkader.

• Programmer (Programmeur):

  • Functie: Werkt als een expert Python-programmeur.
  • Taak: Genereert op basis van de input van de Consultant gestructureerde, modulaire en uitvoerbare Python-code. In de revisie-fase past deze module foutenrapporten en feedback van de Reviewer toe.
  • Doel: Het produceren van bug-vrije code die het probleem numeriek oplost.

• Reviewer (Beoordelaar):

  • Functie: Werkt als een onafhankelijke code-reviewer en expert in wetenschappelijk rekenen.
  • Taak: Evalueert de kwaliteit van de gegenereerde code en de betrouwbaarheid van de numerieke resultaten. De Reviewer analyseert runtime-outputs (stdout, waarschuwingen, fouten) en geeft feedback over algoritmekeuze, debugging en optimalisatie.
  • Doel: Het bieden van zelf-debugging en zelf-refinement capaciteiten door een feedbacklus met de Programmer.

Workflow:
Het proces start met het Herschrijven van het probleem door de Consultant. Vervolgens Oplost de Programmer het probleem. De Reviewer Beoordeelt de output; als er fouten zijn of de oplossing suboptimaal is, start een Herzieningslus waarin de Programmer de code aanpast op basis van de feedback. Dit proces kan iteratief plaatsvinden. Het framework is gebouwd op LangGraph en ondersteunt heterogene modelcombinaties (bijv. verschillende LLMs voor verschillende rollen).

3. Belangrijkste Bijdragen

1. Nieuw Framework: Introductie van het RE4-framework met een "rewriting-resolution-review-revision" logica, specifiek ontworpen voor autonoom wetenschappelijk rekenen zonder domeinspecifiek training.
2. Collaboratieve Architectuur: Een robuust multi-LLM systeem dat significant beter presteert dan enkelvoudige modellen door de krachten van verschillende modellen te combineren (bijv. één model voor redenering, een ander voor code-generatie).
3. Generaliteit: Toepassing en validatie op drie zeer verschillende soorten problemen: partiële differentiaalvergelijkingen (PDE's), slecht gestelde lineaire systemen en data-gedreven fysieke analyse.

4. Resultaten en Evaluatie

Het framework werd getest op drie benchmarks:

• PDE-benchmark: Oplossing van zes vergelijkingen (o.a. Burgers, Poisson, Navier-Stokes).
• Hilbert Lineaire Systemen: Oplossing van slecht gestelde (ill-conditioned) lineaire systemen.
• Data-gedreven Fysieke Analyse: Identificatie van dominante dimensieloze getallen (Keyhole number) op basis van experimentele data.

Kernbevindingen:

• Verbetering in Succesratio: De Reviewer-module verbeterde de "bug-free" en "non-NaN" uitvoeringssuccesratio aanzienlijk voor moderne redenerende modellen:
  • DeepSeek R1: Van 59% naar 82%.
  • ChatGPT 4.1-mini: Van 66% naar 87%.
  • Gemini-2.5: Van 60% naar 84%.
• Afname van Fouten: Er was een duidelijke daling in het aantal niet-fysische oplossingen en runtime-fouten.
• Numerieke Nauwkeurigheid: De relatieve fouten (L2-norm) namen af na elke iteratie van review en revisie. Voor complexe problemen zoals de onstabiele Navier-Stokes-vergelijkingen leidde de feedback van de Reviewer tot algoritme-upgrades (bijv. betere randvoorwaarden, hogere orde discretisatie, ILU-preconditioning), wat resulteerde in stabielere en nauwkeurigere oplossingen.
• Methodeselectie: Het framework slaagde erin om in plaats van simpele methoden, geavanceerde technieken te selecteren die nodig zijn voor specifieke problemen (bijv. Tikhonov-regulering voor Hilbert-matrices).

5. Betekenis en Conclusie

Het RE4-framework stelt een nieuw paradigma voor in wetenschappelijk rekenen: automatische code-generatie en -herziening als een collaboratieve, zelfcorrigerende cyclus.

• Betrouwbaarheid: Het lost het probleem op van onbetrouwbare output van LLMs in kritieke wetenschappelijke toepassingen door een onafhankelijke "Reviewer" te introduceren die runtime-gegevens analyseert.
• Autonomie: Het vermindert de afhankelijkheid van menselijke tussenkomst voor debugging en methodeselectie.
• Toekomstperspectief: Hoewel het framework momenteel meer tokens en tijd kost dan een eenstapsaanpak, biedt het een schaalbare route naar volledig autonome wetenschappelijke softwareontwikkeling. De auteurs wijzen op toekomstige verbeteringen, zoals adaptieve inferentiestrategieën en het integreren van dynamische kennisretrieval voor nog complexere engineeringtaken.

Kortom, dit werk bewijst dat multi-agent samenwerking, geleid door een strikte review-mechanisme, de betrouwbaarheid en nauwkeurigheid van LLM's in wetenschappelijk rekenen drastisch kan verbeteren, waardoor ze bruikbaar worden voor het oplossen van complexe, real-world fysieke problemen.