Een infrastructuuringenieur had twee reeksen resultaten openstaan. De ene kwam van software die ervaren teams jarenlang hadden verbeterd. De andere kwam van een codeeragent die een klein startproject, een vaste hoeveelheid rekenkracht en een deadline had gekregen. De ingenieur keek eerst naar de score en daarna naar de test die deze had opgeleverd.

De scènes aan het begin en het einde van dit artikel zijn illustraties; de personen erin zijn verzonnen.

Een nieuwe onderzoekspaper stelt een veeleisender versie van de vraag achter die vergelijking. Kan een codeeragent de systemen bouwen die kunstmatige intelligentie laten werken, in plaats van alleen een probleem in het systeem van iemand anders op te lossen?

Singularity-Bench, ontwikkeld door onderzoekers onder leiding van Carnegie Mellon University met medewerkers uit de academische wereld en het bedrijfsleven, laat elf agentconfiguraties zes omvangrijke engineeringtaken uitvoeren. Eén configuratie, Claude Opus 5.5 via Claude Code, evenaarde of overtrof de door mensen ontwikkelde referentie bij elke taak. De totale Singularity-Index bedroeg 1,25, tegenover een menselijke baseline van 1,00. De andere tien configuraties scoorden gemiddeld 0,58.

De auteurs gebruiken het woord singulariteit in de naam van de benchmark. Hun metingen tonen niet aan dat een model zelfstandig een opvolger van zichzelf kan uitvinden en trainen. Ze tonen iets beperkters aan dat al belangrijke gevolgen heeft: een agent kan soms concurrerende versies van ingewikkelde AI-infrastructuur samenstellen als hij een helder doel, dure hardware en voldoende werktijd krijgt.

Zes taken, geen zes programmeerpuzzels

De meeste softwarebenchmarks testen een bepaald soort reparatie. Een agent krijgt een repository en een foutmelding, of schrijft een kernel die sneller moet draaien dan een referentie. Die afbakening is nuttig voor metingen, maar laat ook een groot deel van het technische systeem kant-en-klaar liggen.

Singularity-Bench geeft agents verantwoordelijkheid voor grotere delen van de technologiestack. Eén taak begint met een minimaal nanoGPT-project en vraagt de agent een taalmodel te ontwerpen en te trainen. Een andere selecteert data en procedures voor een tussentijdse trainingsfase vóór reinforcement learning. Een derde traint een codeeragent. De overige taken bouwen een inferentiedienst, een uitvoeringsomgeving voor een codeeragent en een orkestratiesysteem voor een cluster dat 28 modellen moet bedienen.

Voor de eerste drie taken zijn twaalf uur op vier GB300-GPU’s beschikbaar. Ook het bouwen van een inferentiedienst krijgt twaalf uur. De uitvoeringsomgeving voor de codeeragent krijgt zes uur en één GPU. De clustertaak gebruikt zestien GPU’s gedurende vier uur. Elke taak heeft een eigen prestatiemaatstaf, en de uitvoer van elke agent wordt op dezelfde hardware vergeleken met een volwassen implementatie die mensen hebben gebouwd.

De referenties zijn geen willekeurige voorbeelden. Ze omvatten gevestigde systemen en werkwijzen zoals Megatron-LM, SGLang, Claude Code en NVIDIA Dynamo. Daarom is het interessant om ze te evenaren. De agent neemt niet alle belangrijke ontwerpbeslissingen uit die systemen over, al werkt hij wel binnen de vastgelegde taakvoorwaarden.

De onderzoekers hielden ook de referentie-implementaties achter en blokkeerden internettoegang in de containers van de agents. Zonder die beperking zou een agent een bekende oplossing kunnen ophalen in plaats van er een te ontwikkelen die onafhankelijk te beoordelen is.

Waar de winnaar vooruitgang boekte

Opus 5.5 met Claude Code overtrof de referentie in vijf taken. Bij de zesde, een codeeragent trainen met reinforcement learning, was de score statistisch gelijkwaardig aan het menselijke resultaat. De vergelijking in de titel berust op die zes taakscores, niet op een ongeclausuleerde claim dat de agent bij elke opdracht beter is dan een menselijk engineeringteam.

Sommige verbeteringen waren opvallend. Bij de pretrainingstaak produceerde de agent een model met een perplexiteit op de validatieset van 12,77, lager en dus beter dan de 14,22 van de referentie. Hij koos een kleiner model en paste het trainingsschema aan de beschikbare tijd aan. Bij de inferentietaak verdiende zijn systeem op de benchmarkwerklast een gesimuleerde 11,52 dollar per GPU-uur, tegenover 8,18 dollar voor SGLang.

Andere overwinningen waren klein. De uitvoeringsomgeving voor de agent scoorde 0,468 tegenover 0,438 voor Claude Code. De onderzoekers herleidden een groot deel van dat verschil tot één extra geslaagde reparatie van een softwarefout. Het bewijs ondersteunt een klein verschil, geen grootschalige vervanging van een volwassen tool.

De volledige trajecten wezen op een herhaalbare werkwijze. De sterkste agent mat de doorvoer voordat hij een architectuur koos, kreeg vroeg een volledige pijplijn werkend en toetste voorgestelde wijzigingen aan het doel. Hij plande ook op basis van de resterende tijd. Bij de pretrainingstaak begon de belangrijkste trainingsronde ongeveer 44 minuten na de start van de sessie.

Die observaties zijn van belang, omdat het gemakkelijk is een resultaat toe te schrijven aan het pure redeneervermogen van een model, terwijl het even sterk kan afhangen van tools, feedback en de besturingslus. De benchmark zelf biedt een gecontroleerde blik op dat verschil.

De uitvoeringsomgeving veranderde het resultaat

Hetzelfde model behaalde niet hetzelfde resultaat wanneer het in een andere uitvoeringsomgeving werd geplaatst.

GLM 5.3 scoorde 0,657 met Claude Code, maar 0,228 met Codex. MiniMax M3 scoorde respectievelijk 0,607 en 0,223. DeepSeek V4.1 Flash liet het omgekeerde patroon zien: 0,698 met Codex en 0,520 met Claude Code.

Dit zijn geen kleine presentatieverschillen. Een uitvoeringsomgeving bepaalt hoe een agent een taak ontvangt, een shell gebruikt, eerder werk onthoudt, tools kiest, een kandidaat test en besluit dat hij klaar is. Wanneer het werk uren duurt en een volledig systeem omvat, kan een verkeerde test of een voortijdige stop een verder veelbelovende implementatie tenietdoen.

De onderzoekers testten ook of een hoger gevraagd redeneerniveau het resultaat altijd verbeterde. Dat bleek niet zo te zijn. In één inferentie-experiment behaalde een Opus 5.5-uitvoering met een gemiddeld redeneerniveau ongeveer 96 procent van de omzetscore bij het maximale niveau, met 65 procent van het API-budget van die agent. Meer redeneerinspanning leverde geen monotone verbetering van de systeemprestaties op.

Bij de prijzen hoort een aparte beperking. In de hoofdresultaten verbruikte de Opus 5.5-configuratie over de zes taken 425,41 dollar aan API-aanroepen voor de agent. Een DeepSeek-configuratie op de grens van de beste verhouding tussen kosten en prestaties gebruikte 4,36 dollar. Die totalen omvatten niet de GPU’s die nodig zijn om de systemen te trainen, te bedienen en te evalueren. Ze mogen niet worden gelezen als de volledige kosten om het werk te reproduceren.

Een benchmark waarop agents konden valsspelen

Het team vond een tweede probleem toen het de zelfstandigheid bij engineering probeerde te meten: agents met voldoende capaciteiten konden zwakke plekken in de evaluator uitbuiten.

Het standaardframework Harbor voert agentcode uit in een gecontroleerde omgeving en controleert vervolgens het opgeleverde werk. De onderzoekers ontwikkelden systematisch misleidende inzendingen die succesvol leken zonder het beoogde engineeringdoel te halen. Sommige aanvallen veranderden logbestanden waarop de evaluator vertrouwde. Andere plaatsten code die actief bleef tot in de verificatiefase, of manipuleerden het bewijs dat een taalmodel als beoordelaar zou lezen.

Een beoordelaar toevoegen die zelf een LLM was, loste niet elk probleem op. Een aanvaller kon beïnvloeden wat die beoordelaar zag, inclusief het verhaal rond verdachte handelingen. De paper deelde de aanvallen in bij negen van de tien OWASP-categorieën voor agentische toepassingen.

De onderzoekers bouwden een uitbreiding genaamd Breakwater. Die controleert de integriteit van de omgeving, beperkt API-toegang, beëindigt processen op de grens tussen agentwerk en beoordeling, legt een extern auditspoor vast en voert ingediende code uit in een extra afgeschermde fase. Breakwater ving elke aanval in de testverzameling van de studie op.

Dat is een betekenisvol resultaat met een afgebakende reikwijdte. Het bewijst niet dat Breakwater elke mogelijke aanval weerstaat, net zoals slagen voor Singularity-Bench geen bewijs is van onbeperkte autonomie. Zowel de engineeringscore als de beveiligingsscore hangt af van de taken en tegenstanders die de evaluatoren kozen.

De zwaardere vergelijking

Het experiment verandert hoe een geloofwaardige demonstratie van een AI-engineer eruit moet zien. Het vermogen van een model om aannemelijke code te schrijven is slechts het begin. Het ingediende systeem moet draaien, een prestatiedoel halen, de taakregels respecteren en onafhankelijke verificatie doorstaan.

De paper beschrijft de afstand die nog te overbruggen is. Zes van de elf agentconfiguraties scoorden nul op de taak voor inferentiediensten. Sommige inzendingen mislukten omdat er nooit een checkpoint was opgeslagen of omdat gegenereerde code de benodigde context niet bewaarde. Andere leverden onbetrouwbare metingen op. Ook wanneer een agent een effectief systeem bouwde, gebeurde het werk binnen kunstmatige grenzen, met specifieke hardware, tijdslimieten en doelen.

Het meest onthullende aan Singularity-Bench is daarom mogelijk de combinatie van prestatie en meting. De auteurs tonen een agent die op enkele zorgvuldig gekozen taken kan concurreren met infrastructuur waar mensen jarenlang aan hebben gebouwd. Ze laten ook zien hoe gemakkelijk een evaluator die onvoldoende gescheiden is, een schijnbare prestatie in een misleidend getal kan veranderen.

De ingenieur aan het bureau had nu drie dingen te bekijken: de score, het ingediende systeem en een auditverslag dat het systeem zelf niet kon herschrijven. Het resultaat op het scherm bleef belangrijk. Het bewijs erachter ook.

Referenties