Technisch Overzicht: Socratic-SWE

Probleemstelling

Door LLM-gestuurde (Large Language Model) software engineering (SWE) agents gedreven wordt, zijn deze een cruciale benchmark geworden voor real-world intelligentie, waarbij langdurige interactie met code-repositories vereist is voor het lokaliseren van bugs, reparatie en verificatie. De training van deze agents wordt echter gehinderd door de schaarste aan hoogwaardige SWE-taken. Bestaande methoden voor synthetische data vertrouwen doorgaans op statische mutatie, bug-injectie of vaste herschrijvingsprocedures. Deze benaderingen genereren taakdistributies die onafhankelijk zijn van de eigen trainingsprogressie en specifieke zwakheden van de agent, wat leidt tot een mismatch tussen het curriculum en de werkelijke capaciteitsverschillen van het model. Bovendien, hoewel reinforcement learning (RL) training waardevolle "solving traces" (opnamen van agentgedrag, toolgebruik en fouten) produceert, worden deze traces door huidige methoden weggegooid nadat de scalaire beloningen zijn geëxtraheerd, waardoor ze niet worden gebruikt om het trainingscurriculum te laten evolueren.

Methodologie: Socratic-SWE

De auteurs stellen Socratic-SWE voor, een gesloten, zelf-evoluerend framework dat historische solving traces transformeert naar gestructureerde trainingssignalen. Het systeem werkt via een co-evolutionaire loop waarbij een gedeelde policy $\pi_\theta$ afwisselt tussen twee rollen: een Generator en een Solver.

1. Agent Skill Registry (Trace Distillatie)

In plaats van traces weg te gooien, destilleert Socratic-SWE deze tot een Agent Skill Registry ($S$). Dit proces omvat drie stadia:

• Trace Collectie: De Solver interacteert met seed-repositories en genereert een corpus van traces ($T$), inclusief zowel succesvolle als mislukte trajecten.
• Skill Extractie: Een distillatiemodel ($M_{distill}$) analyseert deze traces om terugkerende gedragspatronen te identificeren. Voor succesvolle traces extraheert het generaliseerbare strategieën; voor mislukte traces vat het foutmodi en corrigerende principes samen.
• Registry Constructie: Kandidaat-skills worden gededupliceerd en gefilterd om een gestructureerde registry te vormen. Elke skill is een gestructureerd document met een naam, beschrijving, toepasbaarheidsvoorwaarden en een geordende lijst van operaties.

2. Skill-Guided Task Generation

De Generator-rol gebruikt de Agent Skill Registry om gerichte reparatietaken te construeren in echte code-repositories.

• Adaptieve Voorstellen: De Generator samplet een skill $s \in S$ en een repository $r$ om een taak $\tau$ en een verificatiesignaal $v$ voor te stellen. Dit proces is geconditioneerd op bewijslast ($E_t$) verzameld uit de eerdere prestaties van de Solver, waardoor taken gericht zijn op de huidige capaciteitsverschillen.
• Gefaseerde Validatie: Kandidaat-taken ondergaan een vierstaps uitvoering-gebaseerde validatiepipeline in een gesandboxed omgeving:
  1. Formaat: Syntactische geldigheid.
  2. Gronding: Verificatie dat taak-artefacten aanwezig zijn in de repository.
  3. Executie: Stabiliteit en reproduceerbaarheid van de verificatiesuite.
  4. Semantiek: Bevestiging dat de taak onderscheid maakt tussen een falende en een gerepareerde staat.
• Gradient-Aware Reward: Om ervoor te zorgen dat taken niet alleen geldig maar ook nuttig zijn, wordt de Generator beloond op basis van solver-gradient alignment. Het systeem berekent een doel-gradiëntrichting ($G_v$) vanuit een apart gehouden set betrouwbare validatietaken. De beloning voor een kandidaat-taak is de cosinus-gelijkenis tussen de taak-geïnduceerde solver-gradiënt ($g_\tau$) en $G_v$. Dit geeft prioriteit aan taken die de solver in een richting drijven die consistent is met vertrouwde verbeteringen.

3. Repository Repair Solver

De Solver-rol traint op het geaccepteerde curriculum van taken. Het interacteert met de repository-sandbox om patches te genereren. De beloningsfunctie ($r_S$) is meervoudig componentieel en beloont:

• Volledige suite pass (alle tests slagen).
• Partiële reparatiesnelheden.
• Regressie-vermijding (behoud van oorspronkelijk passerende tests).
  De Solver wordt geoptimaliseerd met GDPO (Grouped Direct Policy Optimization) om de heterogene beloningscomponenten effectief te behandelen.

Belangrijkste Bijdragen

1. Trace-Driven Self-Evolution Paradigma: Het paper demonstreert dat solving traces, die normaal gesproken na beloningsberekening worden weggegooid, kunnen dienen als een herbruikbaar substraat voor zelf-evolving agents. Socratic-SWE zet historische gedragingen om in gestructureerde skills die een gesloten trace-skill-taak loop leiden.
2. Gradient-Aware Curriculum Optimalisatie: De auteurs introduceren een curriculummechanisme dat skill-geconditioneerde generatie combineert met uitvoering-gebaseerde validatie en een solver-gradient alignment reward. Dit zorgt ervoor dat gegenereerde taken zowel verifieerbaar als afgestemd zijn op vertrouwde verbeteringsrichtingen.
3. Superieure Empirische Prestaties: Het framework bereikt state-of-the-art resultaten onder identieke compute-budgetten vergeleken met andere zelf-evolving baselines, wat sterke zelf-evolutie en transfer-capaciteiten aantoont.

Experimentele Resultaten

Het framework werd geëvalueerd op vier benchmarks: SWE-bench Verified, SWE-bench Lite, SWE-bench Pro, en Terminal-Bench 2.0. De experimenten gebruikten een vast compute-budget van 36.000 trainingsinstanties (12k per iteratie over 3 iteraties) en vergeleken met vijf zelf-evolving baselines (SPIRAL, R-Zero, Absolute-Zero, Socratic-Zero, SSR) en een base agent.

• Prestaties: Na drie iteraties behaalde Socratic-WEV 50,40% op SWE-bench Verified, een verbetering van +7,80 punten ten opzichte van de base agent en +3,40 ten opzichte van de sterkste baseline (SSR). Het bereikte ook 36,67% op Lite, 22,85% op Pro, en 14,61% op Terminal-Bench 2.0.
• Scaling: In tegen tegenstelling tot baselines die na 2 iteraties stagneren of achteruitgaan, vertoonde Socratic-SWE consistente winst door de derde iteratie. Uitgebreide schaling naar 5 iteraties liet zien dat het een hoger plafond bereikte (52,00%) vergeleken met SSR (48,00%).
• Ablatie-studies: Het verwijderen van de Skill Registry veroorzaakte de grootste prestatiedaling (-4,20 punten), wat bevestigt dat skill-geleid curriculumontwerp de primaire drijfveer is. Het vervangen van trace-distillatie door handmatige skills of het gebruik van standaard GRPO in plaats van GDPO resulteerde ook in significante degradatie.

Betekenis en Claims

Het paper claimt dat Socratic-SWE een schaalbaar substraat biedt voor zelf-evolving SWE agents door de solving traces van de agent zelf te gebruiken om het trainingscurriculum continu aan te passen. De auteurs beargumenteren dat deze aanpak de beperkingen van statische, model-agnostische datasynthese overwint door een dynamische, model-bewuste loop te creëren waarbij:

• Traces worden getransformeerd naar skills.
• Skills gerichte taken leiden.
• Gegenereerde taken nieuwe traces produceren voor verdere evolutie.

De resultaten suggereren dat solving traces voldoende signaal bevatten om duurzame zelfverbetering te drijven zonder externe annotatie, wat effectief de verzadiging van leercurves die bij andere self-play methoden wordt waargenomen, uitstelt. Het framework is bijzonder effectief omdat het de rijke, diagnoseerbare foutmodi gebruikt die inherent zijn aan SWE-traces, gecombineerd met deterministische uitvoering-gebaseerde verificatie.

Beperkingen

De auteurs erkennen verschillende beperkingen:

• Closed-World Setting: De evaluatie vertrouwt op een vaste pool van seed-repositories. Naarmate de Skill Registry vollediger wordt, staat het systeem voor afnemende meeropbrengsten door redundante trainingssignalen.
• Validatie Afhankelijkheid: De methode is afhankelijk van een apart gehouden validatieset om de generator-gradient alignment reward te definiëren, wat de robuustheid kan beperken als de validatiedistributie de doel-deployment setting niet representatief weergeeft.
• Executie Vereisten: De aanpak gaat uit van uitvoerbare verificatie en gesandboxed interactie, wat betekent dat de winst mogelijk niet direct overdraagbaar is naar settings zonder betrouwbare tests of deterministische uitvoering.
• Scope: De evaluatie is momenteel beperkt tot specifieke SWE en terminal-agent benchmarks; bredere transfer naar andere talen of workflows moet nog worden vastgesteld.