🤖 AI

SWE-Hub: A Unified Production System for Scalable, Executable Software Engineering Tasks

SWE-Hub is een geïntegreerd productiesysteem dat de schaarste aan uitvoerbare software-engineeringdata oplost door een gestroomlijnde pijplijn te bieden die reproducible omgevingen, schaalbare bug-synthese en diverse taken voor reparatie en creatie combineert.

Oorspronkelijke auteurs: Yucheng Zeng, Shupeng Li, Daxiang Dong, Ruijie Xu, Zimo Chen, Liwei Zheng, Yuxuan Li, Zhe Zhou, Haotian Zhao, Lun Tian, Heng Xiao, Tianshu Zhu, Longkun Hao, Jianmin Wu

Gepubliceerd 2026-03-03

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Yucheng Zeng, Shupeng Li, Daxiang Dong, Ruijie Xu, Zimo Chen, Liwei Zheng, Yuxuan Li, Zhe Zhou, Haotian Zhao, Lun Tian, Heng Xiao, Tianshu Zhu, Longkun Hao, Jianmin Wu

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 enorme fabriek wilt bouwen die software-engineers (de programmeurs van de toekomst) traint. Deze "robots" moeten leren hoe ze complexe computerprogramma's kunnen bouwen, fouten kunnen vinden en hele nieuwe systemen kunnen ontwerpen.

Het probleem is dat er tot nu toe te weinig echte, werkende oefenmateriaal was. De bestaande oefeningen waren vaak als een poppenhuis: het zag er mooi uit, maar als je er echt in ging werken, viel het stuk. Of ze waren te simpel: "Hier is een foutje in deze ene regel, maak het goed." In het echte leven is software veel ingewikkelder; een fout in de keuken kan ervoor zorgen dat de lift in de kelder niet werkt.

SWE-Hub is de oplossing. Het is geen enkel oefenboek, maar een volautomatische productielijn die eindeloos nieuwe, realistische oefeningen maakt. Hier is hoe het werkt, vertaald in alledaagse termen:

1. De Fundering: De "Onbreekbare Werkplaats" (Env Agent)

Stel je voor dat elke programmeertaal (Python, Java, C++) een andere taal spreekt en andere gereedschappen nodig heeft. Een robot die Python spreekt, kan niet zomaar in een Java-werkplaats werken zonder dat alles kapot gaat.

Het oude probleem: Elke keer een nieuwe werkplek opzetten was als het bouwen van een huis van kaarten. Het was fragiel en viel vaak om.
De SWE-Hub oplossing: De Env Agent is als een magische architect. Hij neemt een ruwe code-bibliotheek en pakt deze in een onbreekbare, zelfstandige container (een soort digitale "bubble").
De analogie: Het is alsof je voor elke oefening een compleet, afgesloten huis bouwt met alle benodigde gereedschappen, stroom en water, zodat de robot er veilig in kan werken zonder dat hij de rest van de wereld verstoort. Of het nu een Python-huis of een Java-huis is, de robot ziet altijd dezelfde, veilige deur.

2. De Productielijnen: Drie Manieren om te Oefenen

Binnen deze veilige werkplaatsen draaien drie verschillende machines die verschillende soorten oefeningen maken:

A. SWE-Scale: De "Fouten-Machine" (Snelle Reparaties)

Wat het doet: Deze machine pakt een werkend programma en gooit er snel duizenden kleine, simpele fouten in. Denk aan het verwisselen van een + voor een - of het vergeten van een puntkomma.
Het doel: Het is een snelheidstraining. De robot moet duizenden kleine fouten zien en repareren.
De analogie: Het is als een simulatorspelletje waar je duizenden kleine lekken in een boot moet dichten. Het is niet diep, maar het bouwt snel reflexen op.

B. Bug Agent: De "Realistische Detective" (Ingewikkelde Fouten)

Wat het doet: In het echte leven weet een gebruiker niet waar de fout zit. Ze zeggen alleen: "Mijn lift werkt niet!" De Bug Agent maakt fouten die ver weg zijn van de symptoom. Hij verandert iets in de kelder, waardoor de lift in de kantoortoren stopt.
Het doel: De robot moet leren redeneren en zoeken, net als een echte detective. De opdracht is niet "fix deze regel", maar "hier is een klacht van een boze gebruiker, vind de oorzaak".
De analogie: Stel je voor dat je een dokter bent. De patiënt zegt: "Mijn maag doet pijn." De Bug Agent zorgt ervoor dat de pijn echt komt van een probleem in je lever, niet van je maag. De robot moet de link leggen tussen het symptoom en de echte oorzaak, zonder dat de oplossing hem in de mond wordt gelegd.

C. SWE-Architect: De "Bouwkundige" (Van Nul Af Bouwen)

Wat het doet: Soms moet je niet repareren, maar bouwen. Deze machine geeft de robot een beschrijving van een nieuw gebouw (bijvoorbeeld: "Bouw een app die foto's opslaat") en een skelet van het project. De robot moet de muren, ramen en deuren zelf plaatsen.
Het doel: Dit test het planningsvermogen. Kan de robot een groot systeem ontwerpen dat overal samenhangend is?
De analogie: Het is alsof je een architect een schets geeft van een huis en een lege bouwput. De robot moet niet alleen de bakstenen leggen, maar ook zorgen dat het dak op de muren past en dat de elektriciteit werkt.

3. De "Magische Controle" (Verificatie)

Het belangrijkste geheim van SWE-Hub is dat het niet kijkt of het antwoord er mooi uitziet.

Oude manier: Een mens kijkt naar de code en zegt: "Ja, dit lijkt wel goed."
SWE-Hub manier: De robot levert zijn werk in, en de fabriek start het programma echt.
- Werkt de lift? -> Goed.
- Crasht de app? -> Slecht.
- Het maakt niet uit hoe mooi de code eruitziet; als het niet werkt, is het fout.

Waarom is dit zo belangrijk?

Vroeger waren AI-modellen voor software zoals leerlingen die alleen theorie hadden geleerd uit een boek. Ze konden formules opschrijven, maar als ze daadwerkelijk moesten bouwen, vielen ze in de war.

SWE-Hub is de praktijkopleiding. Het zorgt ervoor dat de robots:

In een veilige, echte omgeving oefenen (niet in een droomwereld).
Alles leren: van het dichten van kleine lekken tot het bouwen van hele steden.
Leren omgaan met de chaos van het echte leven, waar fouten vaak ver weg zijn van waar je denkt dat ze zitten.

Kortom: SWE-Hub is de fabriek die de volgende generatie super-intelligente software-engineers traint, zodat ze niet alleen kunnen praten over code, maar het ook daadwerkelijk kunnen bouwen en repareren.

Probleemstelling

De vooruitgang van software-engineering (SWE) agents, aangedreven door Large Language Models (LLM's), wordt momenteel beperkt door het gebrek aan uitvoerbare, schaalbare en realistische data voor training en evaluatie. Bestaande pipelines kampen met drie fundamentele uitdagingen:

Fragiele omgevingen: Het reproduceren van uitvoeringsomgevingen is moeilijk over verschillende programmeertalen heen, vaak vanwege complexe toolchains en afhankelijkheden.
Gebrek aan realisme: Synthetische bugs zijn vaak lokaal (binnen één functie) en missen systemische fouten die ontstaan door interacties tussen modules of configuraties.
Korte horizon: De meeste datasets focussen op het repareren van korte fouten ("fix this bug") en negeren langere competenties zoals architecturale planning, afhankelijkheidsmanagement en het bouwen van volledige repositories.

Het genereren van data die "execution-grounded" is (waarbij correctie wordt bepaald door daadwerkelijke uitvoering en tests, niet alleen tekstuele overeenkomst) is computatiever en complexer dan traditionele dataverzameling.

Methodologie: SWE-Hub Architectuur

SWE-Hub introduceert een unificatie van een data-fabriek die ruwe repository-snapshots omzet in diverse, uitvoerbare taken. Het systeem is opgebouwd uit een gedeelde uitvoeringssubstrate en drie gespecialiseerde productlijnen.

1. Uitvoeringssubstrate (Environment Layer)

De basis van het systeem is de Env Agent en Test Agent, die zorgen voor een reproduceerbare uitvoeringsomgeving:

Env Agent: Automatiseert het provisioneren van container-omgevingen (Docker) voor heterogene repositories. Het installeert toolchains en afhankelijkheden en garandeert dat de repository "build-ready" is, zonder dat tests hoeven te slagen.
Test Agent: Ontdekt test-entrypoints en standaardiseert de output naar een machine-leesbaar formaat (bijv. JUnit XML of JSON), ongeacht de gebruikte taal of framework.
Resultaat: Een "pinned" container-image met een gestandaardiseerde verificatie-entrypoint. Dit ontkoppelt de taakgeneratie van de complexiteit van specifieke talen.

2. Productlijn A: SWE-Scale (Schaalbare Reparatie)

Een engine voor hoge doorvoer van lokale bug-fix taken:

Gebruikt een polyglot analyse-backbone (gebaseerd op Tree-sitter) om code-entiteiten te analyseren.
Past procedurale modificaties (regels voor operator-wissels, controle-flow fouten) en LLM-gestuurde herschrijvingen toe om bugs te injecteren.
Verificatie gebeurt in stateless Kubernetes-pods: elke kandidaat-patch wordt geïsoleerd getest. Alleen patches die een "pass-to-fail" (P2F) signaal genereren, worden behouden.
Genereert probleemrapporten die lijken op gebruikersmeldingen, gebaseerd op uitvoeringslogs.

3. Productlijn B: Bug Agent (Realistische Regressies)

Gericht op systemische, niet-lokale fouten die moeilijker te diagnosticeren zijn:

Ripple-effect principe: Injecteert wijzigingen die lokale syntaxis intact laten maar impliciete contracten tussen modules schenden (bijv. API-grenzen, configuratie).
De fouten manifesteren zich ver weg van de broncode-wijziging, wat realistischere debugging-scenario's creëert.
De Issue Agent genereert rapporten die strikt focussen op symptomen en reproduceerbaarheid, zonder hints over de root-cause te geven (anti-leakage).

4. Productlijn C: SWE-Architect (Langere Horizon: Bouwen)

Breidt het takenbereik uit van reparatie naar creatie:

Transformeert bestaande repositories in "build-from-scratch" taken door implementaties weg te halen (code hollowing) terwijl de structuur behouden blijft.
Gebruikt een DOC Agent en API Agent om gestructureerde, natuurlijke taal-specificaties te genereren die als input dienen voor de agent.
Evaluatie gebeurt via verborgen tests (hidden tests) om te controleren of de gegenereerde code functioneel correct is, zonder dat de oplossing bekend is.

Belangrijkste Bijdragen

Unificatie van Data-Fabriek: SWE-Hub is geen statische dataset, maar een productiesysteem dat continu uitvoerbare taken genereert. Het ontkoppelt de omgeving (substrate) van de taakgeneratie.
Automatische Reproduceerbaarheid: De Env Agent fungeert als universele adapter voor ruwe repositories, waardoor taakgeneratie onafhankelijk wordt van taal-specifieke toolchains.
Schaalbare en Realistische Synthese:
- SWE-Scale biedt hoge doorvoer via parallelle validatie.
- Bug Agent zorgt voor hoge fideliteit door systemische regressies te creëren met gescheiden symptomen en oorzaken.
Uitbreiding van Taakhorizon: SWE-Architect introduceert schaalbare taken voor repository-construktie, wat competenties zoals planning en globale consistentie test die in bestaande benchmarks ontbreken.
Gestandaardiseerde Schema: Alle taken volgen een uniek schema ( $T = (f, R, P_{bug}, P, O, V, M)$ ) dat uitvoeringsgegevens, validatiecriteria en metadata koppelt aan een vastomlijnde container-omgeving.

Resultaten en Validatie

Hoewel het paper voornamelijk de architectuur en methodologie beschrijft, worden de volgende resultaten en garanties benadrukt:

Deterministische Uitvoer: Door het gebruik van "pinned" container-images en stateless workers, zijn alle gegenereerde taken exact reproduceerbaar.
Cross-taal Ondersteuning: Het systeem ondersteunt meerdere talen (Python, Java, JS/TS, C/C++, Go, etc.) via declaratieve configuraties (YAML) in plaats van harde code.
Kwaliteit van Data: De filtratie op basis van echte uitvoering (P2F signalen) garandeert dat de gegenereerde bugs actief zijn. De "anti-leakage" mechanismen in de Issue Agent zorgen ervoor dat agents niet kunnen "gokken" op de oplossing door hints in de prompt.
Schaalbaarheid: Het gebruik van Kubernetes maakt het mogelijk om duizenden validaties parallel uit te voeren, wat de productieschaal van data aanzienlijk vergroot.

Betekenis en Impact

SWE-Hub markeert een verschuiving van het handmatig cureren van benchmarks naar een geautomatiseerde, modulaire data-productie.

Betrouwbare Training: Het biedt een continue stroom van hoogwaardige, uitvoerbare data die essentieel is voor het trainen van robuuste SWE-agents.
Representatieve Evaluatie: Door zowel korte reparaties als lange architecturale taken te omvatten, biedt het een vollediger beeld van de capaciteiten van een agent.
Toekomstbestendigheid: Het systeem is ontworpen om zich aan te passen aan nieuwe talen en taakfamilies zonder de kernarchitectuur te hoeven herschrijven.

Kortom, SWE-Hub lost het "execution-grounded" data-probleem op door een industriële aanpak te hanteren, waarbij reproduceerbaarheid, schaalbaarheid en realisme centraal staan in de generatie van software-engineering taken.