Het Dilemma van de Detective: Wanneer Zien Niet Genoeg Is

Stel je voor dat je een detective bent die een mysterie probeert op te lossen, maar in plaats van naar aanwijzingen te kijken, staar je naar één enkele, hoogwaardige foto. In de wereld van kunstmatige intelligentie is dit wat "multimodale modellen" doen: ze kijken naar afbeeldingen en proberen vragen over die afbeeldingen te beantwoorden. Lange tijd zijn deze AI-detectives beter geworden door te leren "tools" te gebruiken. Als een aanwijzing te klein is om te zien, leren ze in te zoomen. Als een tekst wazig is, leren ze de afbeelding te verhelderen. Dit wordt "denken met afbeeldingen" genoemd. Het is alsof je de detective een vergrootglas en een zaklamp geeft.

Er zit echter een addertje onder het gras. Sommige mysteries worden niet opgelost door harder te kijken. Stel je een puzzel voor waarbij je precies moet tellen hoeveel pixels er in een specifiek patroon zitten, of de precieze hoek moet bepalen waarmee een verborgen ring is gedraaid. Geen enkele hoeveelheid zoomen of verhelderen zal je helpen de oplossing met je ogen te "zien". Je moet het berekenen. Hier loopt de oude manier van denken tegen een muur aan. De AI kan de stappen om de puzzel op te lossen in woorden beschrijven, maar woorden kunnen geen wiskunde uitvoeren op een plaatje. Dit papier stapt in die kloof en stelt een eenvoudige maar diepgaande vraag: Wat als de AI niet alleen de oplossing beschreef, maar ook daadwerkelijk een computerprogramma schreef om de oplossing uit te voeren?

Het Grote Idee van het Papier: Codering als Denken

Dit papier introduceert een nieuwe manier voor AI om visuele puzzels op te lossen, genaamd Code-with-Image. In plaats van de AI te vragen om alleen naar een afbeelding te "kijken" en het antwoord te raden, of om een vooraf gemaakte lijst met tools te gebruiken zoals "bijsnijden" of "draaien", geven de onderzoekers de AI een leeg canvas en een Python-interpreter (een tool die computercode uitvoert). De taak van de AI is om een programma te schrijven dat de pixels van de afbeelding direct manipuleert om het antwoord te vinden.

Denk er zo over na: In de oude manier, als je een AI zou vragen: "Hoeveel rode stippen zitten er in deze afbeelding?", zou de AI proberen de stippen te beschrijven of een tool te gebruiken om ze te markeren. In Code-with-Image moet de AI een script schrijven dat zegt: "Loop door elke pixel, controleer of deze rood is, tel het aantal, en print het totaal." Het programma is de redenering. Als de code klopt, klopt het antwoord. Als de code fout is, is het antwoord fout. Dit verschuift de uitdaging van het "zien" van het antwoord naar het "bouwen" van het antwoord.

Het Probleem: AI Kan Beschrijven, Maar Niet Doen

De onderzoekers ontdekten dat zelfs de slimste AI-modellen moeite hebben met dit. Ze testten een enorme benchmark genaamd CwI-Bench (Code-with-Image Bench), die 30 verschillende soorten visuele puzzels bevat. Deze puzzels zijn zo ontworpen dat je ze niet simpelweg kunt "bekijken" om het antwoord te krijgen; je moet een meerstapsberekening uitvoeren op de pixels.

Toen de AI probeerde deze puzzels op te lossen met alleen woorden (zelfs met zijn "denkmodus" ingeschakeld), faalde het jammerlijk. Bijvoorbeeld, het topmodel, GPT-5.6-luna, kreeg minder dan 30% van de antwoorden goed. Het kon de stappen perfect beschrijven ("Ik moet de afbeelding draaien en de pixels tellen"), maar het kon de wiskunde erachter niet daadwerkelijk uitvoeren. Het was als een chef die een recept in perfect detail kan beschrijven, maar niet daadwerkelijk kan koken.

Echter, toen de onderzoekers de AI een Python-interpreter gaven en hem opdroegen om code te schrijven om het probleem op te lossen, schoten de scores omhoog. De nauwkeurigheid van GPT-5.6-luna steeg naar 43%. Het open-source model Qwen3.5-27B ging van 12,6% naar 32,6%. De code stelde de AI in staat om de afbeeldinggegevens daadwerkelijk te verwerken, waardoor een gokspel veranderde in een berekening.

Het Geheime Ingrediënt: Jezelf Leren Debuggen

Maar hier komt de crux: zelfs met het vermogen om code te schrijven, maakte de AI nog steeds fouten. Het schreef een programma dat correct leek te zijn, maar een kleine, onzichtbare fout bevatte—zoals het tellen van één extra pixel of het gebruiken van het verkeerde getal voor een rotatie. De AI voerde de code uit, kreeg het foute antwoord, en probeerde vervolgens gewoon een nieuw programma te schrijven, waarbij vaak dezelfde fout werd gemaakt.

Om dit op te lossen, creëerden de auteurs een "zelfevolgende" lus genaamd Self-Reflection over Executable Reasoning. Dit is het meest speelse deel van het verhaal. Stel je voor dat de AI een student is die een toets maakt. Wanneer hij een vraag fout heeft, wordt hij in plaats van gewoon door te gaan, gedwongen om:

1. Naar zijn mislukte test te kijken: De geschreven code en het foute antwoord lezen.
2. Een simulatie uit te voeren: De code opnieuw draaien in een veilige "sandbox" om precies te zien waar het misging.
3. De bug te repareren: De code aanpassen om de fout te corr corrected.
4. De les op te slaan: Als de reparatie werkt, slaat het de gecorrigeerde code op als een "vaardigheid" (een stuk tekst) in een bibliotheek.

Dit gebeurt zonder dat de AI opnieuw getraind hoeft te worden of dat zijn brein opnieuw bedraad moet worden. Hij leert simpelweg van zijn eigen fouten. Het papier laat zien dat deze "zelflerende" lus ongelooflijk krachtig is.

• Voor het GPT-5.6-luna model verhoogde het gebruik van deze zelfgeëvolueerde vaardigheden de nauwkeurigheid van 43% naar 67%.
• Voor het Qwen3.5-27B model sprong het van 32,6% naar 55,9%.

Waarom Dit Er Toe Doet: Vaardigheden die Je Kunt Kopiëren en Plakken

Een van de coolste bevindingen is dat deze "vaardigheden" gewoon platte tekst zijn. Ze zitten niet opgesloten in het brein van de AI. De onderzoekers lieten zien dat ze de vaardigheden die geleerd zijn door een groot, krachtig model (zoals het model met 27 miljard parameters) konden nemen en deze in een veel kleiner, zwakker model (een model met 9 miljard parameters) konden plakken.

Het kleinere model, dat de problemen op zichzelf niet kon oplossen, werd plotseling veel beter door simpelweg de "referentiegids" te lezen die door het grotere model was geschreven.

• Het 9B-model ging van 11,1% nauwkeurigheid naar 34,5% door enkel de door het 27B-model geëvolueerde vaardigheden te gebruiken.
• Nog verrassender was dat deze vaardigheden werkten over verschillende soorten AI-modellen heen. Een vaardigheid die geleerd door één familie van modellen, hielp een compleet andere familie van modellen te verbeteren.

Wat Dit Papier Uitsluit

Het papier is zeer duidelijk over wat niet werkt. Het betoogt dat het simpelweg geven van een lijst met tools (zoals "zoomen", "bijsnijden" of "zoeken") niet genoeg is voor dit specifieke type problemen. De AI moet zijn eigen algoritme vanaf nul schrijven. Het laat ook zien dat alleen maar "harder nadenken" in woorden niet helpt; de bottleneck is niet een gebrek aan ideeën, maar een gebrek aan uitvoering. De AI kan het algoritme beschrijven, maar zonder de code uit te voeren, kan hij de puzzel niet oplossen.

De Kern van het Verhaal

Dit papier suggereert dat voor visuele problemen die een precieze berekening vereisen, de beste manier voor een AI om te denken het schrijven van code is. Maar de echte doorbraak is dat deze AI-modellen zichzelf kunnen leren hoe ze die code beter kunnen schrijven door hun eigen fouten te debuggen. Ze hebben geen menselijke leraar nodig om hun code te corrigeren; ze hebben alleen een sandbox nodig om de code te draaien, een spiegel om te zien waar ze faalden, en een beetje geduld om het opnieuw te proberen.

De resultaten zijn gemeten en specifiek: op een benchmark van 30 taakfamilies verhoogden zelfgeëvolueerde vaardigheden de prestaties van topmodellen van de lage veertig naar de hoge zestig (procent nauwkeurigheid). Hoewel het papier niet beweert dat dit elk visueel probleem oplost, bewijst het dat voor taken waarbij het antwoord in de wiskunde van de pixels ligt in plaats van in de inspectie van het oog, codering de sleutel is, en zelfreflectie de meestersleutel.