🤖 AI

daVinci-Dev: Agent-native Mid-training for Software Engineering

Het artikel introduceert daVinci-Dev, een framework voor agentische mid-training dat een nieuwe "agent-native" datastrategie benut door contextueel en omgevingsmatig native trajecten te combineren om distributieverschillen te overwinnen, waardoor 32B- en 72B-modellen in staat worden gesteld om state-of-the-art SWE-Bench Verified-prestaties te behalen met aanzienlijk minder trainingstokens dan eerdere methoden.

Oorspronkelijke auteurs: Ji Zeng, Dayuan Fu, Tiantian Mi, Yumin Zhuang, Yaxing Huang, Xuefeng Li, Lyumanshan Ye, Muhang Xie, Qishuo Hua, Zhen Huang, Mohan Jiang, Hanning Wang, Jifan Lin, Yang Xiao, Jie Sun, Yunze Wu, Pengfei

Gepubliceerd 2026-01-28

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Ji Zeng, Dayuan Fu, Tiantian Mi, Yumin Zhuang, Yaxing Huang, Xuefeng Li, Lyumanshan Ye, Muhang Xie, Qishuo Hua, Zhen Huang, Mohan Jiang, Hanning Wang, Jifan Lin, Yang Xiao, Jie Sun, Yunze Wu, Pengfei Liu

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

Het Grote Idee: Een Robot Leren Hoe een Echte Programmeur Te Worden

Stel je voor dat je een robot wilt leren hoe hij een kapotte auto moet repareren.

De Oude Manier (Post-Training):
De meeste huidige AI-modellen zijn als studenten die alle automanuals in de bibliotheek hebben gelezen (Pre-training), maar nog nooit een moersleutel hebben aangeraakt. Om hen te leren auto's te repareren, laten onderzoekers hen enkele video's zien van experts die auto's repareren (Supervised Fine-Tuning) en laten ze vervolgens oefenen in een garage, waarbij ze alleen worden gecorrigeerd wanneer ze een fout maken (Reinforcement Learning).

Het Probleem: De "garage" is klein en duur om te bouwen. Je kunt slechts op een paar auto's oefenen. Bovendien ziet de student alleen de uiteindelijke gerepareerde auto, niet het rommelige proces van proberen, falen, de motor controleren en opnieuw proberen.

De Nieuwe Manier (daVinci-Dev / Agent-Native Mid-Training):
De auteurs van dit paper zeggen: "Laten we de robot leren voordat we hem naar de garage sturen." Ze introduceren een tussenfase genaamd Mid-Training.

In plaats van de robot alleen de afgewerkte auto te laten zien, voeren ze hem een enorme bibliotheek aan echte reparatielogs van miljoenen echte monteurs. Ze laten hem niet alleen het eindresultaat zien; ze laten hem het volledige verhaal zien:

De monteur die naar de kapotte auto kij
De monteur die de motorkap opent en de handleiding leest.
De monteur die een reparatie probeert, een vreemd geluid hoort en beseft dat het niet werkte.
De monteur die een andere reparatie probeert totdat het werkt.

Ze noemen dit "Agent-Native" data omdat het de werkelijke ervaring nabootst van het zijn van een agent (een werker) in de echte wereld, in plaats van alleen statische feiten te memoriseren.

De Twee Speciale Ingrediënten

Om deze trainingsbibliotheek te bouwen, heeft het team twee soorten "verhalen" (data) gemaakt van GitHub (een gigantische website waar programmeurs code delen):

1. De "Contextually-Native" Verhalen (De Brede Bibliotheek)

Wat het is: Ze hebben miljoenen "Pull Requests" (verzoeken om code aan te passen) genomen en het hele verhaal gereconstrueerd.
De Analogie: Stel je een dossier van een detective voor. Het laat niet alleen de opgeloste misdaad zien; het laat ook de detective zien die het dagboek van de verdachte leest, het juiste bestand vindt, een gok doet en vervolgens van gedachten verandert op basis van nieuwe aanwijzingen.
Waarom het helpt: Dit leert de AI de flow van het werk. Het leert dat je, voordat je een bestand bewerkt, het eerst moet opzoeken en lezen. Het dekt een enorme variëteit aan talen en situaties (68,6 miljard woorden aan data).

2. De "Environmentally-Native" Verhalen (De Levende Simulatie)

Wat het is: Ze hebben niet alleen logs gelezen; ze hebben de code daadwerkelijk gedraaid. Ze plaatsten een AI-agent in een echte, werkende computeromgeving (een Docker-container) en lieten het proberen bugs te repareren.
De Analogie: Dit is also[dt] de student in een echte garage te zetten met een echte motor. De student probeert een bout aan te draaien, en de motor maakt een harde klank (een foutmelding). De student hoort de fout, stopt en probeert een ander gereedschap.
Waarom het helpt: Dit leert de AI hoe te reageren op echte feedback. Het leert dat "als ik dit commando typ, de computer tegen mij zal schreeuwen met een foutmelding", wat iets is wat statische boeken niet kunnen leren. Dit deel is kleiner (3,1 miljard woorden) maar van zeer hoge kwaliteit omdat het "echt" is.

De Resultaten: Hoe Goed Werkte Het?

Het team heeft hun nieuwe "student" (het daVinci-Dev model) getest op een beroemde examen genaamd SWE-Bench Verified, wat een soort eindexamen is voor software engineers.

De Score: Hun 72-miljard parameter model behaalde een succespercentage van 58,5%.
De Vergelijking: Dit versloeg de vorige beste open-source methode (Kimi-Dev), die rond de 48,6% scoorde.
De Efficiëntie: Ze bereikten dit met minder dan de helft van de hoeveelheid trainingsdata (tokens) die de vorige recordhouder gebruikte. Het is alsof je een A+ haalt op een toets door 50 uur te studeren in plaats van 100 uur, omdat het studiemateriaal veel beter was.
De Verrassing: Ondanks dat ze begonnen met een "algemeen" basismodel (Qwen2.5-Base) dat niet specifiek voor coderen was getraind, maakte de nieuwe trainingsmethode het beter in coderen dan modellen die als "code-experts" begonnen.

Waarom Dit Belangrijk Is (Volgens het Paper)

Het paper betoogt dat de grootste fout bij het leren programmeren aan AI is geweest: het behandelen van de AI als een student die alleen tekstboeken leest. Echt software engineering is een lus: Probleem vinden → Code lezen → Reparatie proberen → Kijken of het breekt → Opnieuw repareren.

Door de AI data te voeren die deze lus behoudt (zowel het verhaal van het werk als de realtime feedback van de computer), hebben ze een fundament gebouwd dat veel sterker is.

Kortom: Ze hebben de AI niet alleen geleerd hoe code eruitziet; ze hebben het geleerd hoe te denken als een programmeur door het rommelige proces van trial-and-error van echte softwareontwikkeling te simuleren.

Technische Samenvatting: daVinci-Dev: Agent-native Mid-training voor Software Engineering

1. Probleemstelling

De grens van de capaciteiten van Large Language Models (LLM's) in software engineering is verschoven van single-turn codegeneratie naar agentic software engineering, waarbij modellen autonoom complexe repositories moeten kunnen navigeren, bewerken en testen. Hoewel huidige state-of-the-art benaderingen vertrouwen op post-training (Supervised Fine-Tuning gevolgd door Reinforcement Learning), kampt dit paradigma met kritieke beperkingen:

Data-schaarsheid en Mismatch: Post-training wordt beperkt door de intrinsieke capaciteiten van het basismodel en de beperkte hoeveelheid hoogwaardige, uitvoerbare trajecten. De meeste trainingsdata bestaat uit statische, voltooide artefacten (bijv. gemerged commits) die de sequentiële actie-observatie-loops missen die inherent zijn aan echte ontwikkeling.
Distributie-mismatch: Traditionele trainingsdata laat zien wat er is geproduceerd, maar verhult hoe een ontwikkelaar of agent bestanden ontdekte, context onderzocht en oplossingen iteratief verfijnde op basis van testfeedback. Dit creëert een kloof tussen statische trainingsdistributies en de dynamische, feedbackrijke omgeving van echte implementatie.
Onderbelichte Mid-training: Hoewel mid-training (MT) transformatief is gebleken voor domeinen zoals wiskunde en code, hanteren bestaande inspanningen voor software engineering vaak een gefactoriseerde aanpak, waarbij geïsoleerde samples voor atomaire taken (bijv. lokalisatie of bewerking) worden gesynthetiseerd zonder de procedurele context en interactiedynamiek te behouden die een agent ervaart.

2. Methodologie: Agent-Native Mid-Training

Het artikel stelt daVinci-Dev voor, een systematische aanpak voor agentic mid-training die fundamentele agentic gedragingen installeert vóór de post-training. De kerninnovatie is de constructie van Agent-Native Data, gedefinieerd als supervisie die de volledige informatiestroom en de omgevingsdynamiek van echte software engineering behoudt.

De methodologie steunt op twee complementaire trajecttypen:

A. Contextueel-Native Trajecten ( $D_{ctx}$ )

Doel: Het bieden van brede dekking en diversiteit door de volledige ontwikkelcontext te behouden.
Bron: Geconstrueerd uit GitHub Pull Requests (PR's).
Synthese: In plaats van PR's te factoriseren in geïsoleerde taken, reconstrueren de auteurs volledige workflows. Voor elke PR bundelen zij:
- Issue Beschrijving: De probleemspecificatie.
- Relevante Bestanden: Volledige bestandinhoud op de base commit (simulatie van de "lees"-fase).
- Temporele Bewerkingen: Een sequentie van commits met verfijnde commit-berichten en code-diffs (simulatie van de "bewerk"-fase).
- Contextuele Redenering: Door LLM gegenereerde samenvattingen die de brug slaan tussen de issue en de bewerkingen.
Schaal: 68,6 miljard tokens afkomstig van 10M+ PR's over diverse talen (General subset) en Python-georiënteerde repositories (Python subset).

B. Omgevings-Native Trajecten ( $D_{env}$ )

Doel: Het bieden van interactie-authenticiteit en het vastleggen van de iteratieve feedbackloop (Bewerken $\to$ Testen $\to$ Herzien).
Bron: Echte uitvoerbare omgevingen afgeleid van GitHub PR's.
Synthese: Met behulp van het SWE-AGENT framework en GLM-4.6 genereren de auteurs agent-rollouts in Docker-omgevingen die werkelijke unit tests bevatten.
- De agent interacteert met de omgeving en ontvangt echte observaties (tool-outputs, testfouten, runtime-fouten).
- Trajecten worden niet gefilterd op succes; zowel geslaagde als mislukte trajecten worden opgenomen om debugging en foutafhandeling aan te leren.
Schaal: 3,1 miljard tokens (ca. 74k trajecten), verdeeld in passerende ( $D_{env}^{pass}$ ) en falende ( $D_{env}^{fail}$ ) sets.

C. Trainingspipeline

De modellen (gebaseerd op Qwen2.5-Base) ondergaan een tweestaps proces:

Mid-Training (MT): Training op de grootschalige, ongelabelde agent-native corpora ( $D_{ctx}$ en/of $D_{env}$ ). Dit verschuift de capaciteitsdistributie van het model naar een meer "agent-ready" staat.
Post-Training: Supervised Fine-Tuning (SFT) op hoogwaardige agentic trajecten (bijv. $D_{env}^{pass}$ of publieke datasets zoals SWE-smith) om het model af te stemmen op specifieke scaffolds.

3. Belangrijkste Bijdragen

Formulering van Agent-Native Mid-Training: Het artikel definieert en implementeert een mid-training paradigma dat agentic gedrag behandelt als een eersteklasses objectief, waarbij men verder gaat dan gefactoriseerde subtaak-training naar holistische, context-behoudende supervisie.
Grootschalige Data-constructie: De auteurs brengen een praktisch recept uit voor het construeren van twee complementaire datasets:
- Een 68,6 miljard token contextueel-native corpus ( $D_{ctx}$ ) die volledige PR-workflows behoudt.
- Een 3,1 miljard token omgevings-native corpus ( $D_{env}$ ) die authentieke executie-feedbackloops vastlegt.
State-of-the-Art Prestaties: De resulterende modellen, daVinci-Dev-32B en daVinci-Dev-72B, behalen nieuwe state-of-the-art resultaten op SWE-Bench Verified onder open trainingsrecepten met gebruik van agentic scaffolds, ondanks dat ze vertrekken vanuit non-coder base modellen.
Resource-efficiëntie: De aanpak bereikt superieure prestaties met minder dan de helft van de mid-training tokens (73,1B vs. ~150B) vergeleken met het vorige open recept (KIMI-DEV), wat een hogere informatiedichtheid en token-efficiëntie aantoont.

4. Experimentele Resultaten

Geëvalueerd op SWE-Bench Verified met de SWE-AGENT scaffold:

Prestatiewinsten:
- daVinci-Dev-72B: Behaalt een resolutiepercentage van 58,5%, waarmee het de vorige open SOTA (KIMI-Dev op 48,6% met SFT+RL) overtreft en de baselines met sterke SFT overtreft.
- daVinci-Dev-32B: Behaalt een resolutiepercentage van 56,1%, wat een nieuwe SOTA is voor 32B modellen die agentic scaffolds gebruiken, ondanks het vertrekpunt van een non-coder base model (Qwen2.5-32B-Base).
Robuustheid: Het mid-training recept levert consistente winsten op verschillende post-training regimes (Zwakke SFT vs. Sterke SFT) en model schalen (32B vs. 72B).
Generalisatie: De modellen tonen significante verbeteringen op algemene codegeneratie benchmarks (HumanEval, EvalPlus) en wetenschappelijke redeneertaken (GPQA, SciBench), wat suggereert dat agentic mid-training overdraagbare redeneervaardigheden bevordert.
Scaling Laws: Het artikel observeert een sterke log-lineaire relatie tussen trainingsstappen en prestaties ( $R^2 \approx 0,90$ ), wat aangeeft dat het paradigma nog niet verzadigd is en profiteert van verdere schaling.

5. Betekenis en Claims

Het artikel betoogt dat agent-native data de cruciale ontbrekende schakel is voor het schalen van software engineering agents. Door de distributie-mismatch tussen statische trainingsdata en dynamische implementatieomgevingen te overbruggen, demonstreren de auteurs dat:

Fundamentele Gedragingen: Agentic capaciteiten (lokalisatie, iteratieve bewerking, test-gedreven verfijning) kunnen worden geïnstalleerd tijdens mid-training, wat een sterkere fundering creëert voor daaropvolgende post-training.
Synergie van Datatypen: De combinatie van contextueel-native data (voor breedte en code-diversiteit) en omgevings-native data (voor diepte en feedback-authenticiteit) is essentieel. Alleen contextueel-native data verbetert de prestaties, maar het toevoegen van omgevings-native trajecten stelt het model in staat de executie-dynamiek te internaliseren.
Schaalbaarheid: De aanpak biedt een schaalbaar pad voor toekomstige agent-ontwikkeling, waarbij gebruik wordt gemaakt van de enorme beschikbaarheid van publieke repositories en geautomatiseerde omgeving-verificatie om verder te gaan dan de huidige taal- en taakbeperkingen.

De auteurs concluderen dat hun werk een "substantiële computationele investering" (datasets, recepten, checkpoints) aan de gemeenschap biedt om verdere research in dit onderbelichte paradigma te faciliteren.