🤖 AI

Socratic-SWE: Self-Evolving Coding Agents via Trace-Derived Agent Skills

Socratic-SWE introduit un cadre d'auto-évolution en boucle fermée qui transforme les traces de résolution historiques d'un agent en compétences structurées pour générer des tâches de réparation ciblées et vérifiables, permettant ainsi une amélioration continue et atteignant des performances de pointe sur les benchmarks SWE sans dépendre de procédures de mutation fixes.

Auteurs originaux : Chuan Xiao, Zhengbo Jiao, Shaobo Wang, Wei Wang, Bing Zhao, Hu Wei, Linfeng Zhang, Lin Qu

Publié 2026-06-08

📖 5 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : Chuan Xiao, Zhengbo Jiao, Shaobo Wang, Wei Wang, Bing Zhao, Hu Wei, Linfeng Zhang, Lin Qu

Article original sous licence CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Ceci est une explication générée par l'IA de l'article ci-dessous. Elle n'a pas été rédigée ni approuvée par les auteurs. Pour une précision technique, consultez l'article original. Lire la clause de non-responsabilité complète

Imaginez que vous essayez d'apprendre à un robot comment réparer des logiciels défectueux. Habituellement, vous devez écrire des milliers de « devoirs » spécifiques pour le robot, trouver les réponses et les noter. C'est coûteux, lent, et souvent, les devoirs ne correspondent pas aux réelles lacunes du robot.

L'article présente Socratic-SWE, une nouvelle façon d'entraîner ces robots de codage. Au lieu qu'un enseignant distribue des devoirs statiques, le robot s'enseigne à lui-même en analysant ses propres erreurs et réussites, transformant cela en un guide d'étude personnalisé.

Voici comment cela fonctionne, en utilisant des analogies simples :

1. L'ancienne méthode : Le manuel statique

Imaginez un étudiant qui essaie d'apprendre la menuiserie. Dans l'ancienne méthode, un professeur lui donne une pile de 1 000 plans pré-écrits pour réparer des objets.

Le problème : Certains plans sont trop faciles (l'étudiant sait déjà les réparer), et d'autres sont impossibles (l'étudiant n'a pas encore les bons outils). Le professeur ne sait pas ce qui pose problème à l'étudiant en ce moment même.
Le résultat : L'étudiant perd du temps sur des choses qu'il sait déjà faire ou se retrouve bloqué sur des choses qu'il ne peut pas résoudre, et finit par cesser de progresser.

2. La nouvelle méthode : Socratic-SWE (L'apprenti qui s'auto-enseigne)

Socratic-SWE change la donne. Il crée une boucle fermée où le robot agit à la fois comme l'élève et comme le professeur.

Étape 1 : La « Trace » (La relecture vidéo)

Chaque fois que le robot essaie de réparer un bug, il laisse derrière lui une « empreinte numérique » appelée trace. C'est comme une relecture vidéo de tout le processus de pensée du robot :

Où a-t-il regardé ?
Quel code a-t-il modifié ?
Le test a-t-il réussi ou échoué ?
A-t-il accidentellement cassé autre chose ?

Dans le passé, les chercheurs utilisaient seulement ces relectures pour donner une simple note de « Réussite » ou d'« Échec », puis jetaient la vidéo. Socratic-SWE dit : « Attendez ! Regardons à nouveau la vidéo. »

Étape 2 : Distiller les « Compétences » (Le guide d'étude)

Le système regarde toutes les relectures et cherche des modèles (patterns).

Si le robot a échoué : Il remarque : « Oh, chaque fois que j'essaie de réparer un fichier avec trois onglets ouverts, j'oublie d'enregistrer le premier. »
Si le robot a réussi : Il remarque : « Quand je vérifie le journal d'erreurs avant de modifier, je réussis généralement. »

Il transforme ces modèles en un « Registre de compétences de l'agent » structuré. Considérez cela comme un Guide d'étude personnalisé ou une Fiche de triche pour coach. Cela liste précisément ce dont le robot est mauvais (ex : « Ne pas oublier de vérifier les effets secondaires ») et ce qu'il fait bien.

Étape 3 : Générer de nouveaux devoirs (Le quiz personnalisé)

Maintenant, le robot utilise ce Guide d'étude pour créer de nouveaux devoirs.

Au lieu de choisir des bugs au hasard, le robot se demande : « D'après mon Guide d'étude, je rate souvent les "éditions multi-fichiers". Créons un nouveau bug complexe qui nécessite spécifiquement de modifier trois fichiers à la fois. »
Cela garantit que les devoirs sont parfaitement ciblés sur les faiblesses actuelles du robot.

Étape 4 : Le « Verificateur » Gardien

Avant que le nouveau devoir ne soit donné au robot, un Gardien strict le vérifie.

Le bug existe-t-il réellement ?
Le robot peut-il vraiment le réparer ?
Le test est-il fiable ?
Si le devoir est défectueux ou impossible, il est rejeté. Seules les tâches de haute qualité et solubles entrent dans le vivier d'entraînement.

L'« Alignement de Gradient » (La boussole)

Il y a un autre tour de passe-passe ingénieux. Le système ne veut pas seulement que le robot résolve n'importe quel problème ; il veut que le robot s'améliore sur les bonnes choses.

Imaginez une boussole. Le système possède une « direction de confiance » (un ensemble de tâches connues de haute qualité).
Lorsque le robot génère une nouvelle tâche, le système demande : « Est-ce que la résolution de cette nouvelle tâche fait avancer le robot dans la même direction que notre boussole de confiance ? »
Si oui, la tâche est conservée. Si non, elle est rejetée. Cela empêche le robot d'apprendre des « astuces » qui ne fonctionnent que sur des problèmes factices.

Les résultats : Devenir plus intelligent plus vite

Les chercheurs ont testé cela sur quatre benchmarks majeurs (comme des examens finaux pour les agents de codage).

La référence (Baseline) : Un robot standard entraîné sur des données fixes.
La compétition : D'autres robots qui essaient de s'auto-enseigner, mais sans cette méthode spécifique de « Registre de compétences ».
Socratic-SWE : Après seulement trois cycles d'auto-enseignement, il a obtenu un score de 50,4 % au test le plus difficile (SWE-bench Verified). C'était un bond énorme par rapport aux autres, qui stagnaient ou progressaient très lentement.

Pourquoi cela importe

L'article affirme que Socratic-SWE prouve qu'il n'est pas nécessaire d'avoir un humain pour écrire d'interminables nouveaux devoirs. En réutilisant l'historique du robot (les traces) pour construire un guide de compétences, le robot peut générer son propre programme de manière continue. Il transforme ses propres échecs passés en carburant pour son futur, lui permettant d'évoluer et de s'améliorer sans avoir besoin d'un flux constant d'enseignants humains.

En bref : C'est comme un robot qui regarde ses propres replays de matchs, écrit son propre guide d'étude, crée ses propres exercices d'entraînement, puis passe un test pour voir s'il s'est réellement amélioré. Et il s'avère que cette méthode d'auto-coaching fonctionne mieux que d'avoir un humain qui distribue les mêmes vieilles fiches d'exercices.

Résumé Technique : Socratic-SWE

Énoncé du Problème

Les agents d'ingénierie logicielle (SWE) pilotés par des modèles de langage de grande taille (LLM) sont devenus un banc d'essai critique pour l'intelligence réelle, nécessitant une interaction de long horizon avec des dépôts de code pour la localisation de bugs, la réparation et la vérification. Cependant, l'entraînement de ces agents est limité par la rareté des tâches de SWE de haute qualité. Les méthodes existantes de génération de données synthétiques reposent généralement sur la mutation statique, l'injection de bugs ou des procédures de réécriture fixes. Ces approches génèrent des distributions de tâches indépendantes de la progression de l'entraînement de l'agent et de ses faiblesses spécifiques, ce qui conduit à un désalignement entre le curriculum et les lacunes réelles de capacité du modèle. De plus, bien que l'entraînement par apprentissage par renforcement (RL) produise des « traces de résolution » (enregistrements du comportement de l'agent, de l'utilisation d'outils et des échecs) précieuses, les méthodes actuelles rejettent ces traces après l'extraction de récompenses scalaires, échouant ainsi à les utiliser pour faire évoluer le curriculum d'entraînement.

Méthodologie : Socratic-SWE

Les auteurs proposent Socratic-SWE, un cadre en boucle fermée et auto-évolutif qui transforme les traces de résolution historiques en signaux d'entraînement structurés. Le système fonctionne via une boucle de co-évolution impliquant une politique partagée $\pi_\theta$ qui alterne entre deux rôles : un Générateur et un Résolveur (Solver).

1. Registre de Compétences de l'Agent (Distillation de Traces)

Au lieu de rejeter les traces, Socratic-SWE les distille dans un Registre de Compétences de l'Agent ( $S$ ). Ce processus comprend trois étapes :

Collecte de Traces : Le Résolveur interagit avec des dépôts sources, générant un corpus de traces ( $T$ ), incluant des trajectoires réussies et échouées.
Extraction de Compétences : Un modèle de distillation ( $M_{distill}$ ) analyse ces traces pour identifier des modèles comportementaux récurrents. Pour les traces réussies, il extrait des stratégies généralisables ; pour les traces échouées, il résume les modes d'échec et les principes correctifs.
Construction du Registre : Les compétences candidates sont dédoublonnées et filtrées pour former un registre structuré. Chaque compétence est un document structuré contenant un nom, une description, des conditions d'applicabilité et une liste ordonnée d'opérations.

2. Génération de Tâches Guidée par les Compétences

Le rôle du Générateur utilise le Registre de Compétences de l'Agent pour construire des tâches de réparation ciblées dans de réels dépôts de code.

Propositions Adaptatives : Le Générateur échantillonne une compétence $s \in S$ et un dépôt $r$ pour proposer une tâche $\tau$ et un signal de vérification $v$ . Ce processus est conditionné par des preuves ( $E_t$ ) collectées à partir de la performance précédente du Résolveur, garantissant que les tâches ciblent les lacunes de capacité actuelles.
Validation par Étapes : Les tâches candidates subissent un pipeline de validation basé sur l'exécution en quatre étapes dans un environnement de bac à sable (sandbox) :
1. Format : Validité syntaxique.
2. Ancrage (Grounding) : Vérification de l'existence des artefacts de la tâche dans le dépôt.
3. Exécution : Stabilité et reproductibilité de la suite de vérification.
4. Sémantique : Confirmation que la tâche distingue les états d'échec et de réparation.
Récompense Sensible au Gradient : Pour garantir que les tâches ne sont pas seulement valides mais aussi utiles, le Générateur est récompensé sur la base de l'alignement du gradient du solveur. Le système calcule une direction de gradient cible ( $G_v$ ) à partir d'un ensemble de tâches de validation de confiance. La récompense pour une tâche candidate est la similitude cosinus entre le gradient du solveur induit par la tâche ( $g_\tau$ ) et $G_v$ . Cela priorise les tâches qui dirigent le solveur vers une direction cohérente avec les améliorations de confiance.

3. Résolveur de Réparation de Dépôt

Le rôle du Résolveur s'entraîne sur le curriculum de tâches acceptées. Il interagit avec le bac à sable du dépôt pour générer des correctifs (patches). La fonction de récompense ( $r_S$ ) est multi-composante, récompensant :

Le passage complet de la suite (tous les tests réussis).
Les taux de réparation partielle.
L'évitement des régressions (préservation des tests initialement réussis).
Le Résolveur est optimisé via GDPO (Grouped Direct Policy Optimization) pour gérer efficacement les composants de récompense hétérogènes.

Contributions Clés

Paradigme d'Auto-Évolution Piloté par les Traces : L'article démontre que les traces de résolution, typiquement rejetées après le calcul de la récompense, peuvent servir de substrat réutilisable pour des agents auto-évolutifs. Socratic-SWE convertit le comportement historique en compétences structurées qui guident une boucle fermée trace-compétence-tâche.
Optimisation de Curriculum Sensible au Gradient : Les auteurs introduisent un mécanisme de curriculum combinant la génération conditionnée par les compétences avec une validation basée sur l'exécution et une récompense d'alignement de gradient du solveur. Cela garantit que les tâches générées sont à la fois vérifiables et alignées avec les directions d'amélioration de confiance.
Performance Empirique Supérieure : Le cadre atteint des résultats de pointe parmi les bases d'auto-évolution sous un budget de calcul identique, démontrant une forte capacité d'auto-évolution et de transfert.

Résultats Expérimentaux

Le cadre a été évalué sur quatre benchmarks : SWE-bench Verified, SWE-bench Lite, SWE-bench Pro, et Terminal-Bench 2.0. Les expériences ont utilisé un budget de calcul fixe de 36 000 instances d'entraînement (12k par itération sur 3 itérations) et ont comparé le modèle à cinq bases d'auto-évolution (SPIRAL, R-Zero, Absolute-Zero, Socratic-Zero, SSR) ainsi qu'à un agent de base.

Performance : Après trois itérations, Socratic-SWE a atteint 50,40 % sur SWE-bench Verified, soit une amélioration de +7,80 points par rapport à l'agent de base et +3,40 par rapport à la base la plus forte (SSR). Il a également atteint 36,67 % sur Lite, 22,85 % sur Pro, et 14,61 % sur Terminal-Bench 2.0.
Mise à l'échelle (Scaling) : Contrairement aux bases qui plafonnent ou régressent après 2 itérations, Socratic-SWE a montré des gains constants jusqu'à la troisième itération. Une extension de la mise à l'échelle à 5 itérations a montré qu'il atteignait un plafond plus élevé (52,00 %) par rapport à SSR (48,00 %).
Études d'Ablation : La suppression du Registre de Compétences a provoqué la plus forte chute de performance (-4,20 points), confirmant que la conception de curriculum guidée par les compétences est le principal moteur. Remplacer la distillation de traces par des compétences manuelles ou utiliser le GRPO standard au lieu du GDPO a également entraîné une dégradation significative.

Signification et Revendications

L'article affirme que Socratic-SWE fournit un substrat évolutif pour les agents SWE en exploitant ses propres traces de résolution pour adapter continuellement son curriculum d'entraînement. Les auteurs soutiennent que cette approche surmonte les limites de la synthèse de données statiques et agnostiques du modèle en créant une boucle dynamique et consciente du modèle où :

Les traces sont transformées en compétences.
Les compétences guident la génération de tâches ciblées.
Les tâches générées produisent de nouvelles traces pour une évolution ultérieure.

Les résultats suggèrent que les traces de résolution contiennent un signal suffisant pour piloter une auto-amélioration soutenue sans annotation externe, retardant efficacement la saturation des courbes d'apprentissage observée dans d'autres méthodes de self-play. Le cadre est particulièrement efficace car il utilise les modes d'échec riches et diagnostiquables inhérents aux traces de SWE, combinés à une vérification déterministe basée sur l'exécution.

Limites

Les auteurs reconnaissent plusieurs limites :

Environnement en Monde Fermé : L'évaluation repose sur un ensemble fixe de dépôts sources. À mesure que le Registre de Compétences devient plus complet, le système fait face à des rendements décroissants dus à la redondance des signaux d'entraînement.
Dépendance à la Validation : La méthode dépend d'un ensemble de validation tenu à l'écart pour définir la récompense d'alignement du gradient du générateur, ce qui peut limiter la robustesse si la distribution de validation ne représente pas le contexte de déploiement cible.
Exigences d'Exécution : L'approche suppose une vérification exécutable et une interaction en bac à sable, ce qui signifie que les gains pourraient ne pas se transférer directement à des contextes dépourvus de tests fiables ou d'exécution déterministe.
Portée : L'évaluation est actuellement limitée à des benchmarks spécifiques de SWE et d'agents terminaux ; un transfert plus large vers d'autres langages ou flux de travail reste à établir.