DS deepswe.net
Versions linguistiques
Centre d'information DeepSWE

Benchmark DeepSWE : pourquoi GPT devance Claude sur les tâches de développement à long horizon

DeepSWE est un nouveau benchmark d'ingénierie logicielle à long horizon créé par Datacurve. Les résultats publiés placent GPT-5.5 devant Claude Opus 4.7 sur des tâches originales impliquant plusieurs fichiers, ce qui en fait un repère utile, mais spécifique à ce benchmark, pour les développeurs qui choisissent un modèle d’IA pour le code.

Jeu de tâches 113 tâches d'ingénierie originales
Portée des dépôts 91 dépôts open source actifs
Premier du classement public GPT-5.5 avec 70 % de réussite
Ce que cette page explique Aperçu
  • Ce que mesure DeepSWE et pourquoi il est plus réaliste que de courts exercices de code.
  • Comment le classement publié compare aujourd'hui GPT et Claude sur les tâches à long horizon.
  • Quels repères pratiques les développeurs devraient retenir avant de choisir un modèle d’IA pour le code.

Qu'est-ce que DeepSWE ?

Un benchmark conçu pour tester un vrai comportement d'ingénierie au niveau du dépôt, et pas seulement de courts exercices de programmation.

DeepSWE est un benchmark destiné à évaluer les agents de développement de pointe sur des tâches originales d'ingénierie logicielle à long horizon. Il a été présenté par Datacurve pour mesurer la capacité des agents IA à gérer un travail de code réaliste qui demande exploration du dépôt, modifications sur plusieurs fichiers, justesse comportementale et vérification.

Contrairement aux benchmarks dont les tâches sont reprises de pull requests existantes ou de commits publics, les tâches DeepSWE sont écrites de zéro. Datacurve explique que ce choix vise à réduire la contamination par les données d'entraînement et à évaluer la résolution de problème plutôt que le simple rappel.

À quoi sert DeepSWE ?

Il est utile lorsque les équipes accordent de l'importance aux implémentations multi-fichiers, à la vérification et à la fiabilité sous contraintes réelles.

DeepSWE sert à comparer des agents IA de codage sur des tâches plus proches du vrai travail d'ingénierie logicielle que de courts puzzles de programmation. Il aide les chercheurs, les fournisseurs de modèles et les équipes d'ingénierie à voir quels agents savent suivre une demande concise formulée comme par un développeur, inspecter une base de code inconnue, implémenter le changement et conserver le comportement existant.

Le benchmark peut aussi être exécuté par des équipes qui veulent noter un nouvel agent ou reproduire le classement. Datacurve publie le corpus de tâches, les métadonnées, le format des vérificateurs et les instructions pour lancer DeepSWE avec Pier.

Quels sont les avantages de DeepSWE ?

Ce benchmark est conçu pour faire ressortir des écarts de capacité que des évaluations plus petites ou plus saturées peuvent masquer.

DeepSWE se distingue parce qu'il met l'accent sur des tâches originales, une couverture plus large des dépôts et une vérification basée sur le résultat. Ensemble, ces choix en font un meilleur proxy du travail pratique d'un agent de code qu'un benchmark qui mesure surtout le rappel ou de toutes petites modifications.

113 tâches originales d'ingénierie logicielle
91 dépôts open source actifs
5 langages : TypeScript, Go, Python, JavaScript, Rust
668 lignes ajoutées en moyenne dans la solution de référence
1

Des tâches originales réduisent le risque de contamination

Les tâches DeepSWE ne sont pas adaptées de correctifs publics. Le score a donc moins de chances de simplement refléter le fait qu'un modèle ait déjà vu la réponse pendant l'entraînement.

2

Les tâches à long horizon ressemblent au développement agentique

Datacurve indique que les prompts DeepSWE sont plus courts que ceux de SWE-bench Pro, tandis que les solutions de référence demandent nettement plus de code et davantage de fichiers.

3

Une couverture plus large des dépôts

Le jeu de tâches couvre de nombreux dépôts actifs au lieu de se concentrer sur une poignée de projets vedettes, ce qui en fait un proxy plus large du travail quotidien d'un agent de code.

4

Les vérificateurs comportementaux récompensent les bons résultats

Les vérificateurs DeepSWE sont conçus pour tester le comportement observable plutôt que la forme interne de l'implémentation, donc plusieurs solutions correctes peuvent réussir.

Quels sont les résultats du benchmark DeepSWE ?

L'information principale n'est pas seulement le classement, mais l'écart observé entre les familles de modèles de pointe.

Rang Modèle Score DeepSWE Lecture
1 GPT-5.5 [xhigh] 70% +- 4% Meilleur taux de réussite publié sur le classement officiel DeepSWE.
2 GPT-5.4 [xhigh] 56% +- 5% Deuxième au classement global et présenté par Datacurve comme offrant un bon rapport coût-performance.
3 Claude Opus 4.7 [max] 54% +- 5% Proche de GPT-5.4 dans la marge annoncée, mais en dessous de GPT-5.5 sur ce benchmark.
4 Claude Sonnet 4.6 [high] 32% +- 4% Taux de réussite plus faible sur les tâches DeepSWE de longue durée.

Le principal enseignement est l'écart. Datacurve rapporte que les scores DeepSWE couvrent une plage beaucoup plus large que ceux de SWE-bench Pro au sein des mêmes familles de modèles de pointe, ce qui suggère que des tâches originales et de longue durée peuvent révéler des écarts de capacité que des benchmarks publics plus courts ou plus saturés masquent.

Pourquoi DeepSWE suggère-t-il que GPT est plus fort que Claude ?

Le signal est réel, mais il reste observé à l'intérieur d'un seul protocole de benchmark et d'un seul dispositif de notation.

DeepSWE suggère que GPT est plus fort que Claude uniquement dans le cadre mesuré par le benchmark : des tâches originales d'ingénierie logicielle de longue durée exécutées via un environnement d’exécution standardisé. La preuve la plus claire est le classement : GPT-5.5 atteint 70 %, tandis que Claude Opus 4.7 atteint 54 %. GPT-5.4 est placé au-dessus de Claude Opus 4.7 avec 56 %, mais leurs marges d'erreur annoncées se chevauchent.

L'analyse qualitative de Datacurve propose une explication possible de cet écart. Elle indique que GPT-5.5 présentait le taux le plus faible d'omission des comportements explicitement demandés dans les trajectoires DeepSWE examinées, avec GPT-5.4 tout près. La même analyse explique que les configurations Claude rataient plus souvent une branche d'une exigence en plusieurs parties, par exemple en implémentant le chemin synchrone mais pas son équivalent asynchrone.

Cela ne veut pas dire que Claude est faible sur toutes les tâches de programmation. Cela signifie que, selon le protocole des tâches et la méthode de notation de DeepSWE, les modèles GPT étaient plus fiables pour compléter l'ensemble du comportement demandé. Pour les utilisateurs, la conclusion prudente est la suivante : DeepSWE montre qu'à l'heure actuelle GPT devance Claude sur cette catégorie précise d'évaluations d'agents de code de longue durée.

Ce que montre le classement

Il existe bien un avantage dans le benchmark

Le classement publié place actuellement GPT-5.5 en tête, avec un écart large face à Claude Sonnet 4.6 et un écart plus resserré, mais toujours significatif, face à Claude Opus 4.7.

Ce qu'il faut éviter

Ne généralisez pas excessivement le résultat

DeepSWE est un signal fort pour les agents de code de longue durée, mais ce n'est pas un classement universel valable pour chaque base de code, chaque mix de langages ou chaque workflow produit.

Qu'est-ce que cela signifie pour les utilisateurs d'outils de code ?

Utilisez le benchmark comme signal d'aide à la décision, puis mettez les finalistes à l'épreuve sur vos propres dépôts.

Pour les utilisateurs qui choisissent un modèle IA pour programmer, DeepSWE invite à évaluer les modèles sur le travail que vous devez vraiment accomplir. Si votre tâche consiste à modifier plusieurs fichiers dans un dépôt inconnu, un benchmark de longue durée peut être un signal plus pertinent qu'un petit quiz de code ou qu'un classement trop saturé.

Le résultat suggère aussi que le taux de réussite n'est pas le seul signal pratique. Datacurve suit les tokens de sortie, le temps écoulé et le coût par essai, et rapporte que davantage de tokens, davantage de temps ou un coût plus élevé ne donnent pas systématiquement de meilleurs résultats. Les développeurs devraient comparer la fiabilité, le coût, la latence et la fréquence à laquelle un modèle manque une exigence.

Une démarche raisonnable consiste à utiliser DeepSWE comme un point de données propre à ce benchmark, puis à tester les meilleurs modèles candidats sur vos propres dépôts, langages et standards de revue avant de standardiser un assistant de code.

Signal 01

Faites correspondre le benchmark à votre flux de travail

Donnez la priorité aux évaluations de longue durée lorsque vos développeurs font surtout de l'exploration de dépôt et des changements multi-fichiers.

Signal 02

Mesurez la fiabilité, pas seulement la vitesse

Suivez les exigences manquées, la reprise de travail, le coût et la latence en plus du taux de réussite brut avant de choisir un modèle par défaut.

Signal 03

Organisez votre propre comparaison

Les benchmarks réduisent le champ, mais votre choix final doit venir de tests sur votre propre dépôt, votre niveau d'exigence en revue et votre tolérance au risque.

Tâches DeepSWE et mode d'exécution du benchmark

Le benchmark couvre des travaux de dépôt variés, et le guide de démarrage rapide est pensé pour des exécutions d'agents reproductibles.

Couverture des tâches

Quelles tâches sont incluses dans DeepSWE ?

DeepSWE comprend 113 tâches stables couvrant des dépôts TypeScript, Go, Python, JavaScript et Rust. Parmi les exemples publiés par Datacurve figurent l'annulation de lectures de corps en attente lors de l'arrêt, la correction du tri des labels PromQL, l'ajout de lecture de fichiers de configuration à des outils en ligne de commande, l'ajout d'une détection déterministe des conflits sur les écritures Y.Map, ainsi que l'ajout d'opérations XML de diff, patch et merge.

Comportement d'exécution Gestion de l'arrêt, annulation, cycle de vie asynchrone et comportements sensibles aux régressions.
Structures de données Tri, pagination, structures Map, instantanés, composition de schémas et règles de conflit déterministes.
Outillage développeur Lecture de config CLI, manifests, linting, profilage, caches et rapports générés.
Démarrage rapide

Comment exécuter DeepSWE ?

Datacurve indique que les tâches DeepSWE sont compatibles Harbor et peuvent être exécutées avec Pier, un framework d'évaluation d'agents de code en sandbox. Le guide officiel clone le dépôt DeepSWE, installe Pier, puis lance un agent et un modèle choisis sur le répertoire des tâches.

git clone https://github.com/datacurve-ai/deep-swe
uv tool install git+https://github.com/datacurve-ai/pier

# GPT-5.5 avec Codex
export OPENAI_API_KEY=...
pier run -p deep-swe/tasks --agent mini-swe-agent --model openai/gpt-5.5

# Claude Opus 4.7 avec Claude Code
export ANTHROPIC_API_KEY=...
pier run -p deep-swe/tasks --agent mini-swe-agent --model anthropic/claude-opus-4-7