DeepSWE uitgelegd: hoe de AI-codebenchmark werkt

Om de paar maanden verschijnt er een nieuwe codebenchmark met dezelfde belofte: origineel, vrij van contaminatie, de tot nu toe meest zuivere maatstaf voor AI-engineering.

DeepSWE is anders. Niet omdat die claims onjuist zijn, maar omdat er daadwerkelijk bewijs achter zit, en omdat Datacurve ongewoon open was over waar de benchmark nog tekortschiet. Laten we eens kijken.

Wat is DeepSWE?

DeepSWE is een contaminatievrije codebenchmark van Datacurve die frontier-LLM's test op 113 originele, langlopende software-engineeringtaken in 91 repositories en vijf talen: TypeScript, Go, Python, JavaScript en Rust. Het werd afgelopen mei gelanceerd als Datacurve's eerste publieke product.

Om duidelijk te zijn: DeepSWE is een benchmark, geen AI-model of codeagent. Het schrijft geen code. Het evalueert agents die dat wel doen. Het doel is te meten of large language models echte, complexe software-engineeringtaken aankunnen, met originele problemen die specifiek voor de benchmark zijn geschreven in plaats van overgenomen uit eerder gemergde GitHub-pull requests.

Daartoe trekt DeepSWE een duidelijke lijn tussen codegeneratie en agentisch coderen. Codegeneratie is een functie produceren in een tekstvak. Agentisch coderen betekent een repository lezen, begrijpen hoe de onderdelen in elkaar grijpen, code schrijven die met bestaande systemen samenwerkt, tests draaien en itereren.

Hoe DeepSWE werkt

Een agent die op DeepSWE wordt geëvalueerd krijgt niet alleen een prompt om in het luchtledige code te schrijven. Hij opereert in een live softwareontwikkelomgeving:

1. De agent ontvangt een taakbeschrijving (gemiddeld zo'n 2.158 tekens, ongeveer de helft van een typische SWE-bench Pro-prompt).
2. Hij inspecteert de repository, navigeert door bestanden en begrijpt de codebase.
3. Hij past code aan, draait relevante commando's en voert tests uit.
4. Hij dient zijn implementatie in.
5. DeepSWE evalueert het resultaat met een taakspecifieke verifier die controleert of de gevraagde functionaliteit er daadwerkelijk is.
6. De uitkomst telt mee voor het algehele slagingspercentage van het model op de benchmark.

DeepSWE gebruikt mini-swe-agent (de harness gebouwd door het Princeton- en Stanford-team achter SWE-bench en SWE-agent) die voor elk model gelijk wordt gehouden. Het is het vermelden waard: de DeepSWE-score van een model weerspiegelt zijn prestaties onder een specifieke configuratie, niet een abstracte maatstaf van codevaardigheid.

Wat maakt DeepSWE anders?

Er zijn veel codebenchmarks en de meeste beginnen in elkaar over te lopen. Dit is wat DeepSWE daadwerkelijk onderscheidt.

Originele software-engineeringtaken

Het belangrijkste verschil tussen DeepSWE en SWE-bench en varianten daarvan is contaminatiecontrole. Elke taak is vanaf nul geschreven door de engineers van Datacurve, niet aangepast van bestaande GitHub-commits of pull requests. De contaminatiezorg is eenvoudig: als een model is getraind op data die zowel het GitHub-issue als de uiteindelijke fix bevat, lost het het probleem niet op, maar herinnert het zich een oplossing. DeepSWE maakt een shallow clone van de basiscommit zodat er geen gemergde fix-hash te lezen valt, waarmee een maas in de wet wordt gedicht die op SWE-bench Pro uit te buiten was.

Langetermijn-ingenieursproblemen

SWE-bench Pro-taken vereisen gemiddeld 120 regels code over vijf bestanden. DeepSWE-referentieoplossingen voegen gemiddeld 668 regels toe over zeven bestanden, ruwweg 5,5 keer zo groot. Dit zijn geen fixes van één functie. Het zijn gecoördineerde wijzigingen in meerdere bestanden, het soort werk dat vereist dat je echt begrijpt hoe een codebase in elkaar steekt. Kortere prompts, grotere oplossingen.

Aangepaste verificatie

Elke taak wordt beoordeeld door een handgeschreven verifier die de gevraagde functionaliteit controleert en elke implementatie accepteert die deze levert. Dit verschilt van testgebaseerde beoordeling, waarbij het criterium is dat specifieke testcases slagen. De verifiers van DeepSWE controleren gedrag, niet implementatie. Wanneer een onafhankelijk LLM beoordeelde runs herbeoordeelt, is het een orde van grootte minder vaak oneens met de verifier van DeepSWE dan met de overgeërfde tests van SWE-bench Pro (1,4% versus 32,4%).

Reproduceerbare evaluaties

De v1.1-revisie van DeepSWE maakt dit nog robuuster, door alleen de gecommitete patch te beoordelen in een schone, geïsoleerde verifier-container en een natuurlijkere git-werkruimte op main te presenteren. Gepubliceerde evaluatietrajecten laten iedereen niet alleen de scores bekijken, maar ook de daadwerkelijke redenering erachter. Je kunt elke rollout doorbladeren in de DeepSWE GitHub-repository.

Hoe het DeepSWE-leaderboard werkt

Het leaderboard op deepswe.datacurve.ai is niet alleen een ranglijst. Het is een configuratietabel, en als je dat begrijpt, lees je het anders.

Slagingspercentage

De kernmetric is pass@1: het aandeel taken dat het model bij de eerste poging oplost. Op veel openbare leaderboards clusteren topmodellen in een smalle bandbreedte. DeepSWE is gebouwd om te weerspiegelen hoe developers agents dagelijks daadwerkelijk ervaren, wat betekent dat het verschil tussen de beste en slechtste prestaties veel groter is.

Redeneerinspanning

Hetzelfde model kan meerdere keren voorkomen met verschillende instellingen voor redeneereffort (high, xhigh, max) en betekenisvol verschillende scores opleveren. Meer redeneereffort betekent doorgaans meer tokens en hogere kosten per taak. Of die afweging loont, hangt af van jouw use-case.

Kosten per taak

De benchmark houdt het tockengebruik en de kosten bij. Een model dat 70% scoort voor $4 per taak versus een dat 68% scoort voor $1,50 per taak vertelt een heel ander verhaal voor een team dat aan productie denkt.

Tokens en agentstappen

Tockengebruik en het aantal tool-use-stappen geven je inzicht in efficiëntie. Sommige configuraties schrijven en draaien intensief hun eigen tests. Op DeepSWE deden topmodellen dit in wel 85% van de runs. Dat zelfverificatiegedrag is een van de duidelijkste markers die sterke agents van zwakkere scheiden.

Evaluatieconfiguratie

Een leaderboardscore is specifiek voor de configuratie. Het model, de agent-harness, beschikbare tools en uitvoeringsinstellingen beïnvloeden allemaal de prestaties. Twee runs van hetzelfde model met verschillende harnesses kunnen verschillende resultaten opleveren. 

Welke AI-modellen presteren het best op DeepSWE?

De onderstaande tabel weerspiegelt het officiële DeepSWE v1.1-leaderboard per 22 september, 2026. Dit zijn configuratiespecifieke resultaten, geen universele ranglijsten. Alle scores hebben een 95%-betrouwbaarheidsinterval van ongeveer ±3-4 procentpunten op een benchmark met 113 taken.

Drie modellen op 74% klinkt als een driestrijd. Maar betrouwbaarheidsintervallen en configuratieverschillen maken die lezing wankel. Labs blijven DeepSWE 1.1-cijfers publiceren voor modellen waaronder GPT-6.1 Sol, Claude Opus 5.5, Sonnet 5.5, Gemini 4 Argon en anderen sinds de laatste officiële update, dus het concurrentielandschap verschuift sneller dan het officiële leaderboard laat zien. Een verschil van een of twee procentpunt tussen toppers is geen betekenisvol signaal, niet op een benchmark met 113 taken en niet gezien de beoordelingsproblemen hieronder beschreven.

DeepSWE versus andere AI-codebenchmarks

DeepSWE vs. SWE-bench

SWE-bench kaderde software-engineeringevaluatie als het oplossen van echte GitHub-issues op 2.294 taakinstanties gedolven uit gemergde pull requests. De taken zijn echt, maar die herkomst creëert een contaminatieprobleem: oplossingen zijn publiek beschikbaar in dezelfde repositories waarop modellen zijn getraind. De originele taken van DeepSWE zijn specifiek geschreven om dit te vermijden. De afruil is schaal: 113 taken versus duizenden.

DeepSWE vs. SWE-bench Pro

SWE-bench Pro reikt verder dan de oorspronkelijke SWE-bench, maar heeft een beoordelingsprobleem dat aanzienlijk bleek. Datacurve's audit vond dat de geautomatiseerde graders van SWE-bench Pro correcte oplossingen 24% van de tijd afwezen en verkeerde 8,5% van de tijd accepteerden, wat betekent dat grofweg een derde van de pass/fail-beslissingen twijfelachtig is. Claude Opus vertoont ook de neiging om in meer dan 12% van de SWE-bench Pro-proeven gouden oplossingen uit de githistorie op te diepen, iets wat DeepSWE's shallow-clone-aanpak voorkomt. Het grotere aantal taken van SWE-bench Pro is een echt voordeel voor statistisch vertrouwen; DeepSWE's schonere beoordeling is een voordeel voor de geldigheid van resultaten. Geen van beide is hier een duidelijke winnaar.

DeepSWE vs. Terminal-Bench

Terminal-Bench 4.0 is een benchmark van 66 taken in terminalomgevingen over zeven domeinen: software, wetenschap, machine learning, operations, hardware, security en media. Waar DeepSWE software-engineering op repositoryniveau evalueert, beoordeelt Terminal-Bench end-to-end technisch werk in een terminal, en slechts 18 van de taken zijn softwaretaken. Terminal-Bench-scores horen bij een model-en-harness-paar, waardoor het deels een toolvergelijking is; DeepSWE houdt de harness vast en vertelt je iets over het model. Beide zijn door Epoch AI als Flawed beoordeeld, Terminal-Bench 4.0 met defecten in 30 van de 66 taken.

Hoe betrouwbaar is DeepSWE?

Aan de sterke kant: originele taken verlagen het contaminatierisico aanzienlijk, de gedragsverifiers zijn nauwkeuriger dan die van SWE-bench Pro, en gepubliceerde trajecten maken resultaten inzichtelijk. Onafhankelijke benchmarkfirma Artificial Analysis verving SWE-bench Pro door DeepSWE voor zijn Intelligence- en Coding Agent-indices (een betekenisvolle steunbetuiging van een organisatie zonder belang bij het succes van Datacurve).

Aan de probleemkant: een onafhankelijke review identificeerde beoordelingsdefecten in minstens 23 van de 113 taken, boven de drempel om de benchmark als Flawed te bestempelen. De review werd op 7 september 2026 gepubliceerd door Epoch AI als onderdeel van hun onafhankelijke Benchmark Reviews-programma. De beoordelingsdefecten waren meestal verborgen tests die botsten met tests die de agent schreef, een structureel probleem waarbij de verifier van DeepSWE de inzending toepast, bestanden herstelt die in de testpatch staan, vervolgens suites draait uit de ingediende repository en hun rapporten beoordeelt. Daardoor blijft een deel van de testinfrastructuur onder controle van de inzending.

Dit maakt DeepSWE niet nutteloos. Het maakt nauwkeurige rangschikkingen onbetrouwbaar. De brede ordening van modellen is waarschijnlijk betekenisvol; een kloof van één of twee procentpunt tussen configuraties niet.

Wat DeepSWE ons vertelt over AI-codeagents

Modellen die goed presteren op DeepSWE schrijven niet alleen betere functies. Ze navigeren door onbekende codebases, plannen meerstapswijzigingen en verifiëren zichzelf via tests. Elke AI-modelfamilie faalt ook op een eigen, karakteristieke manier. Datacurve rapporteert dat een groot deel van Claude's falen op DeepSWE een "one branch shipped"-patroon volgt: gedeeltelijke implementaties die aan enkele maar niet alle vereisten voldoen. Dat is een andere faalmodus dan die van GPT, die weer verschilt van die van Gemini.

Redeneerinspanning, kosten en prestaties interageren op manieren die niet netjes te simplificeren zijn. De staplimiet is zelden bindend: slechts 67 van de 7.174 gescoorde rollouts raakten het plafond. Meer tokens en meer stappen lossen niet consequent meer taken op, wat de moeite waard is om te weten voordat je een agent voor productie configureert.

De hardere waarheid is dat benchmarkprogressie, hoe echt ook, niet aantoont dat agents zelfstandig complexe productiesystemen kunnen onderhouden. Een pass rate van 74% op 113 zorgvuldig ontworpen taken zegt iets zinvols over relatieve modelcapaciteit. Het zegt niet dat een agent onbeheerd kan worden vertrouwd in een productiecodebase, dubbelzinnige vereisten aankan of de sociale dynamiek van een echt engineeringteam navigeert. Die gaten worden door geen enkele huidige benchmark gemeten.

Conclusie

DeepSWE is een echte verbetering ten opzichte van de benchmarks die het moest vervangen. Originele taken, gedragsverificatie en gepubliceerde trajecten maken het betrouwbaarder dan SWE-bench Pro voor het vergelijken van frontiermodellen op zwaar engineeringwerk. DeepSWE-slagingspercentages lopen grofweg 70 procentpunten uiteen van slechtst tot best, tegenover ongeveer 30 punten op publiek gerapporteerde SWE-bench Pro-scores, en die bredere scheiding is echt en informatief.

Maar leaderboardresultaten moeten voorzichtig worden gelezen. Configuratie doet er enorm toe: redeneereinspanning, kosten en harness-keuzes verschuiven allemaal de scores. En de onafhankelijke beoordelingsreview vond defecten in meer dan 20% van de taken, genoeg om precieze rangschikkingen als richtinggevend in plaats van definitief te behandelen. Benchmarkontwerp blijft echt moeilijk, en DeepSWE is een eerlijke poging voor een probleem dat nog geen schone oplossing heeft.

Wil je de skills aanscherpen die benchmarks zoals DeepSWE willen meten, dan behandelt onze cursus AI-Assisted Coding for Developers prompt engineering, debuggen en testworkflows met AI-codeassistenten. De vervolgcursus, Advanced AI-Assisted Coding for Developers, gaat dieper in op codebase-analyse, prestatieoptimalisatie en security, het soort meerstaps engineeringwerk waar de best scorende agents van vandaag nog steeds mee worstelen.