Act-Observe-Rewrite: Multimodal Coding Agents as In-Context Policy Learners for Robot Manipulation

Dit paper introduceert Act-Observe-Rewrite (AOR), een framework waarin een multimodaal taalmodel robotmanipulatie verbetert door zonder gradiëntupdates, demonstraties of beloning-engineering visuele observaties te gebruiken om de uitvoerbare Python-controllercode tussen proeven te herschrijven op basis van gediagnosticeerde fouten.

De kern

Stel je voor dat je een robotarm hebt die een taak moet uitvoeren, zoals een blokje oppakken en ergens neerzetten. Normaal gesproken leer je zo'n robot door duizenden voorbeelden te tonen (zoals een kind dat leert door te kijken) of door een computerprogramma te laten "trainen" met duizenden pogingen en fouten, waarbij de computer langzaam zijn interne instellingen aanpast.

Deze paper, getiteld "Act–Observe–Rewrite" (Handelen–Observeren–Opnieuw Schrijven), stelt een heel andere, slimme manier voor. Het is alsof je de robot niet traint, maar een slimme programmeur aanstelt die elke keer na een mislukking de handleiding herschrijft.

Hier is de uitleg in simpele taal, met een paar creatieve vergelijkingen:

1. Het Probleem: De "Zwarte Doos" vs. De "Open Boek"

Stel je een moderne robot voor als een zwarte doos. Je geeft hem een opdracht, hij probeert het, en als hij faalt, weet je niet precies waarom. Misschien was zijn "instelling" net iets te laag, of zag hij het object verkeerd. Om dit op te lossen, moet je vaak duizenden keren proberen en de doos van binnen aanpassen (zoals het herschrijven van een recept terwijl je kookt, maar zonder te weten wat er misgaat).

De auteurs van dit papier zeggen: "Waarom proberen we de robot niet te laten leren door zijn eigen code te lezen en aan te passen?"

In plaats van een ondoorzichtige "neural network" (een soort digitaal brein dat we niet begrijpen), schrijven ze de robot aan met gewone Python-code. Dit is als een open boek. Als de robot faalt, kan een AI (een groot taalmodel) het boek openen, lezen wat er staat, en zeggen: "Ah, hier staat dat we het blokje moeten pakken, maar de formule voor de afstand is verkeerd! Laten we die regel aanpassen."

2. Hoe het werkt: De Cyclus van Drie Stappen

Het systeem heet Act–Observe–Rewrite. Het werkt als een slimme leerling die elke dag een nieuwe proefpoging doet:

• Act (Handelen): De robot probeert de taak. Hij pakt het blokje, probeert het neer te zetten.
• Observe (Observeren): De robot kijkt wat er gebeurt. Hij maakt foto's en noteert: "Ik heb het blokje gemist," of "Mijn grijper is vastgelopen."
• Rewrite (Opnieuw Schrijven): Dit is het magische deel. Een AI (zoals een superprogrammeur) kijkt naar de foto's en de code. Hij denkt na: "Ik zie dat de robot het blokje mist omdat hij denkt dat het 5 cm links staat, terwijl het rechts staat. De formule in de code is fout!"
  • De AI schrijft de code van de robot volledig opnieuw.
  • De volgende keer dat de robot probeert, gebruikt hij deze nieuwe code.

Er wordt geen gewicht getraind (geen duizenden uren rekenkracht nodig) en er zijn geen voorbeelden nodig van een mens. De robot leert puur door zijn eigen fouten te analyseren en de instructies aan te passen.

3. De Vergelijking: De Chef-kok die zijn recept herschrijft

Stel je een chef-kok voor die een taart bakt.

• De oude manier: De kok proeft de taart, zegt "te zoet", en probeert de volgende keer iets minder suiker te doen. Hij doet dit 100 keer. Hij weet niet waarom het misging, hij raadt alleen.
• De AOR-methode: De kok schrijft het recept op. Na de eerste mislukte taart leest hij het recept en zegt: "Oh, ik heb de suiker in de verkeerde volgorde toegevoegd, of de ovenstand is verkeerd berekend." Hij pakt zijn pen, schrijft het recept zelf aan, en de volgende keer bakt hij een perfecte taart.

In dit geval is de "kok" de robot, en de "recept" is de computercode die de robot bestuurt.

4. Wat hebben ze ontdekt? (De Resultaten)

De onderzoekers testten dit met drie taken in een simulatie:

1. Een blokje tillen: De robot faalde eerst omdat hij dacht dat het blokje lager was dan het was (een camera-fout). De AI zag dit, schreef de formule voor de diepte-aanduiding aan, en daarna lukte het 100%.
2. Een blikje in een bakje doen: De robot zag het blikje niet, omdat hij dacht dat het zilver was, terwijl het in de camera rood leek. De AI zag dit, veranderde de kleur-instellingen in de code, en het lukte weer 100%.
3. Blokjes opstapelen: Dit was het moeilijkst. De robot bleef het onderste blokje duwen terwijl hij het bovenste neerzette. De AI zag dit in de foto's, maar kon helaas geen oplossing vinden om dit te voorkomen. De robot bleef steken op 91% succes.

5. Waarom is dit belangrijk?

• Geen duizenden voorbeelden nodig: Je hoeft geen menselijke demonstraties te geven. De robot leert alleen door te proberen en te lezen.
• Volledig inzicht: Omdat het om code gaat, weten we precies wat er misging. We kunnen de AI vragen: "Waarom faalde je?" en hij antwoordt: "Omdat de formule voor de camera-hoek verkeerd was."
• Snel aanpassen: Als je de robot in een nieuwe kamer zet met andere lichten, hoeft hij niet opnieuw te trainen. De AI kijkt naar de nieuwe situatie, ziet de fout, en schrijft de code direct aan.

Conclusie

Deze paper laat zien dat robots niet per se "moeten leren" zoals mensen (door duizenden keren te oefenen), maar dat ze kunnen leren door hun eigen instructies te herschrijven. Het is alsof je een robot een bril geeft die hem laat zien waar zijn eigen code fout is, zodat hij zichzelf kan repareren.

Het is een enorme stap naar robots die zelfstandig kunnen werken in onze wereld, zonder dat we ze eerst duizenden uren hoeven te "trainen". Ze worden niet slimmer door meer data, maar door slimmer na te denken over hun eigen fouten.

Technische samenvatting

Hier is een gedetailleerde technische samenvatting van het paper "Act–Observe–Rewrite: Multimodal Coding Agents as In-Context Policy Learners for Robot Manipulation" van Vaishak Kumar (General Bionix, Inc.), vertaald en samengevat in het Nederlands.

Titel: Act–Observe–Rewrite (AOR): Multimodale Codeer-Agenten als In-Context Policy Learners voor Robotmanipulatie

1. Het Probleem

Robotmanipulatie bevindt zich in een overgangsfase naar integratie met foundation-modellen (zoals Vision-Language-Action modellen). Hoewel deze modellen goed kunnen generaliseren, blijven twee grote uitdagingen bestaan:

1. Diagnose en Adaptatie: Wanneer een model faalt in een specifieke deploy-configuratie, is het moeilijk om de oorzaak te diagnosticeren en aan te passen zonder het model opnieuw te trainen (retraining).
2. Kosten en Toegankelijkheid: De kosten voor pre-training en rekenkracht maken het voor onderzoekers onhaalbaar om snel te itereren op nieuwe manipulatietaken.

Bestaande methoden zoals Reflexion (verbaal zelfreflectie) werken goed in tekstuele omgevingen, maar falen vaak in fysieke omgevingen waar success afhangt van precieze kinematica, ruis in visuele data en objectfysica. Verbaal reflecteren is niet voldoende om complexe motorische fouten te corrigeren.

2. Methodologie: Het AOR Framework

De auteurs introduceren Act–Observe–Rewrite (AOR), een raamwerk waarin een Large Language Model (LLM) de robotbeleidspolicy verbetert door volledig nieuwe, uitvoerbare Python-controllercode te synthetiseren tussen proeven door.

Kernprincipes:

• Twee-tijdsschaal Loop:
  • Snelle loop: De robot voert een episode uit met een Python-controller.
  • Trage loop: Tussen episodes door analyseert een multimodaal LLM (Claude Code) de resultaten.
• Policy als Code: In tegenstelling tot methoden die parameters aanpassen of kiezen uit een vooraf gedefinieerde bibliotheek van vaardigheden, is de hele implementatie van de motorische controle (de Python-class) het eenheid van redenering.
• De Cyclus:
  1. Act: De robot voert een taak uit.
  2. Observe: Aan het einde van de episode worden gestructureerde data (beloningen, fase-logs, minimale afstand) en sleutelframe-beelden (key-frame images) verzameld.
  3. Rewrite: Het LLM analyseert deze multimodale input, diagnosticeert de fout (bijv. "de Y-coördinaat in de back-projection is verkeerd voor OpenGL"), en schrijft een nieuwe controller-class. Deze code wordt gecompileerd, gevalideerd in een sandbox en geladen voor de volgende proef.

Veiligheidsmechanismen:
Om te voorkomen dat het LLM gevaarlijke code genereert, worden de volgende maatregelen genomen:

• Compilatie Sandbox: Code wordt geïsoleerd getest; als het niet compileert of de interface mist, valt het systeem terug op de vorige werkende controller.
• Actie-Clamping: Bewegingen worden begrensd binnen veilige grenzen.
• Beperkte Rewrites: Het LLM wordt aangemoedigd om gerichte wijzigingen te maken in plaats van de hele structuur te vervangen.

3. Belangrijkste Bijdragen

1. Architecturale Innovatie: AOR beweert dat het maken van de volledige controller-implementatie het object van LLM-redenering, een kwalitatief andere vorm van in-context learning mogelijk maakt dan bij "zwarte doos" neurale policies. Het agent kan niet alleen zien dat het mislukt, maar waarom (op code-niveau).
2. Autonome Foutdiagnose: Het systeem kan systematische fouten in visuele pipelines (zoals camera-conventies of kleursegmentatie) autonoom ontdekken en corrigeren zonder menselijke tussenkomst.
3. Geen Demonstraties of Beloningen: Het systeem leert zonder menselijke demonstraties, zonder handmatige beloningsfunctie-engineering en zonder gradient updates.
4. Interpreteerbaarheid: Omdat de policy in leesbare Python-code bestaat, kunnen mensen de redenering en de wijzigingen direct auditeren.

4. Experimentele Resultaten

De methode werd getest op drie taken in de Robosuite-simulatieomgeving (UR5e arm):

• Lift (Rede kubus tillen):
  • Resultaat: 100% succes.
  • Leerproces: Het LLM diagnoseerde een visuele dieptebias (8-9 cm fout) en corrigeerde de back-projection-formule. Vervolgens werd een "stationaire grijp" strategie geïmplementeerd om het object niet te destabiliseren tijdens het sluiten van de grijper.
• PickPlaceCan (Blik in bak plaatsen):
  • Resultaat: 100% succes.
  • Leerproces: Het systeem ontdekte dat het blik in de camera rood leek in plaats van zilver (kleurprobleem) en dat de rode marker in de bak de centroid-berekening verstoorde. Het LLM schreef de kleur-detectie-logica opnieuw.
• Stack (Kubus op kubus stapelen):
  • Resultaat: 91% succes (na 20 iteraties).
  • Leerproces: Het systeem corrigeerde complexe visuele bugs (OpenGL vs. OpenCV coördinatenconventies) die tot 8 cm fouten leidden.
  • Beperking: De resterende 9% faalde omdat de grijper de onderste kubus raakte tijdens het plaatsen. Het LLM diagnoseerde dit correct, maar vond geen strategie om dit contact te vermijden (lokaal optimum).

Vergelijking: Een vervangend agent (Codex/GPT-5) faalde volledig op dezelfde taken, wat aantoont dat de capaciteit van het onderliggende coderende LLM cruciaal is.

5. Betekenis en Conclusie

AOR positioneert zich als een complementaire aanpak tot bestaande Vision-Language-Action (VLA) modellen:

• VLA-modellen optimaliseren voor breedte (generalisatie over honderden taken via pre-training).
• AOR optimaliseert voor diepte en interpreteerbaarheid (hoge prestaties op specifieke taken via gerichte redenering en code-wijziging).

Kerninzicht: Het vermogen om fouten te diagnosticeren op het niveau van code-logica (bijv. een tekenfout in een wiskundige formule) en deze direct te corrigeren, biedt een krachtig alternatief voor duur en traag trainen met reinforcement learning. Het systeem kan visuele en kinematische bewijzen gebruiken om de oorzaak van falen te vinden en de oplossing direct in de controller te coderen.

Toekomstperspectief: Hoewel de resultaten in simulatie veelbelovend zijn, blijft de overdracht naar echte robots een uitdaging vanwege sensorruis. Toekomstig werk richt zich op het combineren van AOR met moderne perceptiemethoden en het oplossen van zoekproblemen waarbij het agent vastloopt in lokale optimums.