🤖 AI

OpenComputer: Verifiable Software Worlds for Computer-Use Agents

Het paper introduceert OpenComputer, een door verifiers onderbouwde raamwerk dat verifieerbare softwarewerelden voor computergebruiksagenten construeert door applicatiespecifieke staatverifiers, een zelfevoluerende verificatielaag, een taakgeneratiepijplijn en een evaluatieharnas te integreren om aanzienlijke gaten in de robuustheid van huidige frontier- en open-source-agenten bloot te leggen, ondanks hun gedeeltelijke vooruitgang.

Oorspronkelijke auteurs: Jinbiao Wei, Qianran Ma, Yilun Zhao, Xiao Zhou, Kangqi Ni, Guo Gan, Arman Cohan

Gepubliceerd 2026-05-20

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Jinbiao Wei, Qianran Ma, Yilun Zhao, Xiao Zhou, Kangqi Ni, Guo Gan, Arman Cohan

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je voor dat je een robot leert om je dagelijkse klusjes te doen, zoals het organiseren van je digitale bestanden, het bewerken van een foto of het verzenden van een e-mail. Je wilt dat de robot perfect is, maar hoe weet je of hij de klus eigenlijk wel goed heeft uitgevoerd?

Dit is het probleem dat het OpenComputer-artikel aanpakt. De auteurs hebben een nieuwe "trainingszaal" gebouwd voor AI-agenten die computers gebruiken, maar met een zeer specifieke draai: ze kijken niet alleen naar het werk van de robot; ze controleren het huiswerk van de robot met een strenge, onwankelbare blik.

Hieronder wordt uitgelegd hoe OpenComputer werkt, via eenvoudige analogieën:

1. Het Probleem: De Valstrik van "Fake It Till You Make It"

In het verleden was het testen van AI op computers vergelijkbaar met het beoordelen van een studentenscriptie door alleen naar de kaft te kijken. Als de kaft er mooi uitzag, gaf de leraar (een AI-rechter) misschien een A. Maar de student had de eigenlijke scriptie misschien leeg gelaten of volgeschreven met onzin.

In de digitale wereld kan een AI een screenshot maken van een document dat er afgewerkt uitziet, maar als het bestand erin eigenlijk leeg is of de instellingen verkeerd zijn, kan de "AI-rechter" de fout missen omdat hij alleen de afbeelding ziet, niet de data.

2. De Oplossing: De "Digitale Inspecteur"

OpenComputer verandert het spel door een verifieerbare softwarewereld te bouwen. In plaats van alleen naar het scherm te kijken, installeert het een team van gespecialiseerde "Inspecteurs" (genaamd Verifiers) in elke applicatie die de AI gebruikt.

De Taak van de Inspecteur: Stel je een bibliothecaris voor die niet alleen naar de kaft van het boek kijkt. Hij opent het boek, controleert de paginanummers, verifieert de naam van de auteur en zorgt ervoor dat de tekst overeenkomt met de database van de bibliotheek.
Hoe het werkt: Voor elke app (zoals een webbrowser, een fotobewerkingsprogramma of een spreadsheet) bouwt OpenComputer een aangepast script dat direct met het "brein" van de app kan "praten". Het stelt vragen zoals: "Is het bestand daadwerkelijk opgeslagen?" "Heeft de gebruiker echt op die knop geklikt?" "Staat de tekst in de juiste cel?"

3. Het Vierstaps Bouwproces

Het artikel beschrijft een vierstaps productielijn om deze perfecte testscenario's te bouwen:

Stap 1: Bouw de Inspecteurs. Ze creëren een "sleutel" voor elke app die het systeem toelaat om in de verborgen staat van de software te kijken (bestanden, instellingen, geschiedenis) in plaats van alleen maar te raden op basis van het scherm.
Stap 2: De Zelfverbeterende Lus. Ze testen deze inspecteurs met een "sterke" AI. Als de inspecteur zegt "Goed gedaan" maar de AI heeft het eigenlijk verknald, vangt het systeem de fout op. Het corrigeert vervolgens de code van de inspecteur, waardoor deze voor de volgende keer slimmer wordt. Het is als een coach die een speler ziet oefenen en vervolgens de trainingsapparatuur aanpast om nauwkeuriger te zijn.
Stap 3: Creëer de Taken. Zodra de inspecteurs betrouwbaar zijn, genereert het systeem 1.000 realistische taken (zoals "organiseer deze 50 bestanden" of "bewerk deze foto"). Omdat de inspecteurs klaar zijn, heeft elke taak duidelijke, machine-controleerbare "slagen" of "zakken"-criteria.
Stap 4: Het Eindexamen. Ze laten de AI-agenten in een frisse, schone digitale ruimte werken. De agenten proberen de taken op te lossen en de Inspecteurs beoordelen ze direct op basis van de feitelijke data, niet alleen op basis van de afbeeldingen.

4. Wat Ze Vonden

Toen ze de beste AI-modellen (zoals GPT-5.4 en Claude) testten in deze nieuwe zaal, vonden ze enkele verrassende dingen:

Het "Bijna"-Probleem: Zelfs de slimste AI's worstelen om een hele taak perfect af te ronden. Ze komen vaak 80% van de weg, maar zakken op de kleine, uiteindelijke details (zoals het bestand opslaan in de verkeerde map).
De "Valse" Succes: De oude manier van beoordelen (het gebruik van een AI om screenshots te bekijken) was te vergevingsgezind. Het gaf hoge scores aan agenten die leken te slagen, maar eigenlijk faalden bij de datacontroles. De nieuwe "Hard-Coded Verifier" was veel strenger en liep beter in de pas met wat een mens zou zeggen.
De Open-Source Kloof: Sommige open-source modellen die er geweldig uitzagen bij andere tests, presteerden hier plotseling zeer slecht. Dit suggereert dat ze goed waren in het "raden" van het juiste antwoord voor eenvoudige tests, maar de complexiteit van echte, rommelige computertoepassingen niet aankonden.

5. De Grote Les

OpenComputer is niet zomaar een lijst met taken; het is een nieuwe standaard voor waarheid.

Denk er als volgt over: het is een overstap van een "eerlijkheidssysteem"-toets (waar de AI zegt: "Ik heb het gedaan!") naar een "bewaakte examen" waarbij een robot-examenbewaker elk antwoord controleert tegen het antwoordmodel. Het artikel concludeert dat AI, hoewel het beter wordt in het kijken naar schermen, nog een lange weg te gaan heeft voordat het betrouwbaar complexe, real-world computerwerk kan doen zonder subtiele maar kritieke fouten te maken.

Kort samengevat: OpenComputer heeft een digitale speeltuin gebouwd waar de regels worden gecontroleerd door code, niet door giswerk, en waaruit blijkt dat de AI-agenten van vandaag nog steeds leren hoe ze echt betrouwbare digitale werknemers kunnen zijn.

Technische Samenvatting: OpenComputer

Probleemstelling

De schaalvergroting van computergebruik-agenten wordt momenteel geblokkeerd door twee kritieke uitdagingen: de hoge kosten voor het bouwen van realistische, reproduceerbare desktopomgevingen, en de moeilijkheid om taaksucces te verifiëren in complexe softwaretoestanden. Traditionele taakcreatie vereist handmatig ontwerp van gebruikersdoelen en omgevingsinitialisatie (bijv. het aanmaken van bestanden, het configureren van instellingen), wat tijdrovend en niet-gestandaardiseerd is. Bovendien vertrouwt evaluatie vaak op "LLM als rechter" of visuele inspectie van screenshots, wat subtiel fouten in onderliggende applicatietoestanden, bestandsmetadata of persistente neveneffecten die niet visueel zichtbaar zijn, niet detecteert. Bestaande benchmarks zijn grotendeels door mensen samengesteld, beperkt in schaal, en missen vaak betrouwbare, machine-controleerbare beloningssignalen.

Methodologie: Het OpenComputer Framework

OpenComputer is een door verifiers onderbouwd framework dat is ontworpen om verifieerbare softwarewerelden te synthetiseren voor computergebruik-agenten. Het behandelt verificatie niet als een downstream-evaluatiestap, maar als het organiserend principe voor omgevings- en taakconstructie. Het framework bestaat uit vier nauw gekoppelde componenten:

1. Applicatie-specifieke State Verifiers

OpenComputer bouwt een verificatiestapel op waarbij elke ondersteunde applicatie wordt gekoppeld aan een synthetische Python-verifiermodule die binnen een sandbox draait.

Inspectiekanalen: Verifiers maken gebruik van de meest betrouwbare applicatie-specifieke inspectiekanalen die beschikbaar zijn, zoals browser-debuggingprotocollen (CDP), D-Bus, SQLite-gebaseerde profiel databases, toegankelijkheids-API's (AT-SPI) en directe bestandsparsing (bijv. voor Inkscape, VS Code of Blender).
Endpointconstructie: Het systeem genereert CLI-subcommando's met JSON-uitvoer die gestructureerde statetoestanden blootleggen (inhoud, voorkeuren, geschiedenis, metadata).
Testprotocol: Verifiers ondergaan een strikte debug-fix-herhaal-lus met unit- en integratietests om ervoor te zorgen dat ze de daadwerkelijke softwaretoestand betrouwbaar inspecteren in plaats van te vertrouwen op heuristische matching.

2. Zelf-evoluerende Verificatielaag

Om resterende fouten in verifiers aan te pakken (bijv. breekbare schema-aannames of onvolledige dekking), implementeert OpenComputer een zelf-evolutielus:

Kalibratie: Een kleine set makkelijke tot gemiddelde taken wordt uitgevoerd door een sterke agent in een sandbox.
Diagnose van Meningsverschillen: Een LLM-evaluator en de programmatische verifier produceren onafhankelijk oordelen over de eindtoestand. Meningsverschillen die worden toegeschreven aan verifierfouten (in plaats van agentfalen) worden geïdentificeerd.
Verfijning: De verifiercode, endpoints of documentatie worden verfijnd op basis van deze feedback. Dit proces wordt herhaald totdat de verifier overeenkomt met het referentieoordeel of een budget is uitgeput.

3. Taakgeneratiepijplijn

Taken worden gesynthetiseerd via een verifier-bewust proces:

Voorstel: Het systeem stelt realistische gebruikersdoelen voor zonder te conditioneren op bestaande verifiers om diversiteit te waarborgen.
Filtering: Voorstellen worden gefilterd op complexiteit en data-genereerbaarheid, met prioriteit voor meerstapsworkflows.
Gronding: Taken worden verankerd in de verificatiestapel. Als een toestand inspecteerbaar is maar geen endpoint heeft, wordt een nieuw endpoint gegenereerd.
Synthese: Het systeem materialiseert de taak door vereiste bestanden, configuraties en profielen te genereren, en outputt een taakinstantie $\tau = (x, e, c)$ waarbij $x$ de instructie is, $e$ de omgevingsinitialisatie, en $c$ de machine-controleerbare succescriteria.

4. Evaluatieharnas

Het harnas voert agenten uit in verse desktop-sandboxes en neemt volledige screenshot-actie-trajecten op. Succes wordt berekend door de checker-commando's van de taak uit te voeren tegen de uiteindelijke softwaretoestand. De beloning is het fractie van geslaagde checks ( $R = N_{pass}/N_{total}$ ), wat gedeeltelijke krediet toestaat terwijl exacte, machine-controleerbare succesccondities worden behouden.

Belangrijkste Bijdragen

OpenComputer Framework: Een door verifiers onderbouwd systeem voor het automatisch genereren van realistische softwarewerelden, taakbeschrijvingen en verifiers zonder handmatige constructie.
Betrouwbaarheidsvalidatie: Empirisch bewijs dat hard-coded verifiers dichter bij menselijke adjudicatie liggen dan LLM-als-rechter-evaluatie, met name voor fijnmazige applicatietoestanden.
Grootschalige Benchmark: Een release bestaande uit 33 desktopapplicaties en 1.000 afgeronde taken die browsers, kantoorsoftware, creatieve software, ontwikkelomgevingen en communicatie-apps omvatten.

Experimentele Resultaten

De auteurs evalueerden frontier- en open-source-agenten op de OpenComputer-benchmark:

Frontierprestaties: GPT-5.4 behaalde de hoogste prestaties met een volledig taaksuccespercentage van 68,3% en een gemiddelde beloning van 88,4%. Claude-Sonnet-4.6 (64,4%) en Kimi-K2.6 (58,8%) volgden. Ondanks hoge gedeeltelijke voortgang blijft betrouwbare end-to-end voltooiing moeilijk.
Open-source Kloof: Open-source modellen vertoonden significante prestatiedalingen in vergelijking met hun gerapporteerde scores op bestaande benchmarks zoals OSWorld. Bijvoorbeeld, GUI-OWL-1.5-8B daalde van een OSWorld-score van 52,3% naar 5,7% op OpenComputer.
Efficiëntie: GPT-5.4 was het meest efficiënt, met gemiddeld 19,0 stappen per taak, deels vanwege het vermogen om bewerkingen te combineren en lange redeneringssporen in de output te vermijden.
Verificatie-uitlijning: In een vergelijking van 120 taken kwamen hard-coded verifiers in 94,1% van de gevallen overeen met menselijke oordelen, tegenover 79,2% voor een LLM-rechter. De verifier was bijzonder superieur in het detecteren van fouten in terminallogs, ingeklapte panelen en precieze bestandsmetadata die screenshots missen.
Impact van Zelf-evolutie: De zelf-evoluerende verificatielaag repareerde 89,4% van de fouten aan de checker-zijde in kalibratietaken, en verbeterde de overeenstemming tussen mens en checker van 85,2% naar 94,1%.

Betekenis en Claims

De auteurs claimen dat OpenComputer een fundamentele infrastructuur biedt voor het schalen van computergebruiksonderzoek door realistische softwarewerelden te koppelen aan machine-controleerbare feedback. De auteurs betogen dat:

Verificatie Kritiek is: Schaalbare synthese voor agenten moet worden gekoppeld aan betrouwbare inspectie in plaats van zwakke proxy-evaluaties zoals LLM-rechters of screenshots.
Huidige Beperkingen: Zelfs frontier-agenten worstelen met end-to-end voltooiing in realistische desktopworkflows, wat een kloof in robuuste computerautomatisering blootlegt.
Toekomstige Nut: Het framework ondersteunt niet alleen evaluatie, maar ook trainingspijplijnen (bijv. SFT, RL) door auditabele, verankerde beloningen te bieden. Het dient als een gecontroleerd startpunt voor het bestuderen van agentbetrouwbaarheid en faalmodi in complexe softwareomgevingen.

De auteurs erkennen beperkingen met betrekking tot taken die visuele of geometrische oordelen vereisen (bijv. ruimtelijke lay-out in Draw.io) die niet volledig kunnen worden gereduceerd tot programmatische checks; dergelijke taken zijn uitgesloten van de hoofdbenchmark om reproduceerbaarheid te waarborgen, maar worden vrijgegeven voor toekomstig hybride verificatieonderzoek.