A-CODE-LLM Bench: un benchmark de codage agentique
Nous avons benchmarké les meilleurs grands modèles de langage (LLMs) sur 10 tâches de développement logiciel en utilisant un outil CLI agentique. Nous avons exécuté environ 3 500 étapes de validation automatisées par modèle, à la fois sur les couches API et UI.
Résultats du benchmark A-CODE-LLM
Chaque alias a été exécuté 3 fois sur 10 tâches (30 échantillons par alias, 380 cellules par itération pour 38 alias). Voir plus de détails sur la méthodologie.
- Sonnet intermédiaire bat le fleuron Opus. Les deux versions de Sonnet surpassent chaque Opus, y compris Opus 4.8 (0.702). Le niveau le plus cher d'Anthropic n'est pas son meilleur codeur.
- Le sommet n'est plus seulement Anthropic : Grok 4.5 (0.732) bat toutes les variantes d'Opus. Le nouveau fleuron d'OpenAI, GPT 5.6 Sol, enregistre le meilleur score de la société (0.615), toujours 0.157 en dessous de Sonnet 5, et ses variantes pro à calcul plus élevé se situent principalement en dessous de leurs bases respectives (Sol Pro 0.543, Terra Pro 0.568 ; seul Luna Pro s'améliore, 0.603 contre 0.579).
- Les spécialistes du code n'ont pas gagné le benchmark de codage. GPT 5.3 Codex, la variante accordée au code d'OpenAI, obtient 0.572, au milieu du peloton et en dessous du GPT 5.4 Mini généraliste d'OpenAI (0.594). Kimi K2.7 Code de Moonshot est le spécialiste le plus fort à 0.611.
- Aucun modèle n'est fiable sur le backend : le plafond est 0.701 (Sonnet 5), donc même le meilleur échoue environ un tiers des vérifications de logique métier et de contrat. Grok 4.5 s'en approche le plus parmi les ajouts de juillet avec 0.663. Le frontend est presque résolu chez les leaders (0.79 à 0.96), donc le backend est le problème ouvert, et il détermine le classement. Claude Haiku 4.5 rend bien (0.731), mais un backend à 0.277 le contient à 0.413.
- Le point faible de GPT est le frontend. GPT 5.4 et 5.5 égalent Opus 4.8 sur le backend (environ 0.6) mais obtiennent 0.53 à 0.55 sur le frontend ; la famille GPT 5.6 monte cela à 0.63 à 0.71, encore loin des plus de 0.91 de la lignée Sonnet.
Comparaison coût & succès
- Les modèles au prix du fleuron sont le pire rapport qualité-prix. Opus 4.7 est le plus cher ($3.08/cellule) et obtient 0.610, en dessous de Sonnet 4.6 à $1.33.
- Le haut de gamme facture une lourde prime pour un gain minime : Sonnet 5 obtient 0.024 de plus que Sonnet 4.6 pour 70% de coût supplémentaire par cellule.
- Grok 4.5 est le nouveau meilleur rapport qualité-prix : 0.732, à 0.040 du gagnant, à $0.46 par cellule, contre $2.23 pour Sonnet 5. Dans la famille GPT 5.6, le prix n'apporte rien : $0.18 (Luna) à $2.76 (Sol Pro) par cellule pour des scores entre 0.543 et 0.615, l'alias le moins cher surpassant le plus cher.
Comparaison temps de completion & succès
- Le meilleur score est parmi les plus lents. Sonnet 5 prend environ 30 minutes par tâche, 3x Sonnet 4.6 pour 0.024 de plus ; Sonnet 4.6 donne presque le même score en un tiers du temps.
- Une longue exécution signale généralement un modèle bloqué, pas un modèle minutieux : les moins bons, les deux variantes Qwen, GLM 5.1 de base et Deepseek V4 Pro, ont chacun tourné plus de 1 700 secondes par over-iteration pour des scores inférieurs à 0.45.
- Grok 4.3 a été rapide parce qu'il a abandonné tôt : 142 secondes et 18 appels d'outils pour 0.431. Grok 4.5 garde la vitesse et abandonne l'arrêt précoce : environ 9 minutes par tâche, moins du tiers du temps de Sonnet 5, pour 0.732.
Appels d'outils par tâche
- Le nombre d'appels d'outils ne mesure ni la capacité ni l'effort que vous pouvez comparer. Sonnet 5 a fait le plus d'appels (125) et a obtenu le meilleur score ; MiniMax M3 a fait 108 pour un milieu de peloton à 0.583 ; Grok 4.5 a atteint 0.732 avec 40 ; les faibles 16 à 36 d'OpenAI viennent du fait que apply_patch regroupe tout un fichier en un seul appel. Sol Pro et Terra Pro appellent entre un quart et un tiers d'outils en moins que leurs bases et obtiennent moins : plus de raisonnement, moins d'exécution. Ne classez pas les agents par volume d'outils.
- Deux chemins mènent au même score : Sonnet 5 itère lourdement (125 appels), Sonnet 4.6 à peine (environ 50), écart de 0.024.
Performance des LLM sur une tâche réussie unique
Aucun modèle n'a réussi chaque étape du benchmark complet ci-dessus. Pour comparer le coût et la vitesse à conditions égales, nous avons exécuté une tâche de base simple que chaque modèle peut accomplir : quatre endpoints CRUD, validation basique, pas d'authentification et pas de base de données.
Comparaison coût & lignes de code
- Les tâches simples ne peuvent pas classer les modèles, donc les évaluations jouets sont trompeuses. Sur la ligne de base que chaque modèle réussit, le code converge vers 40 à 64 lignes, et le coût tombe à quelques centimes ; les différences n'apparaissent que sur les longs travaux multi-fichiers.
- Le niveau « rapide et léger » a été le plus cher ici : Gemini 3.5 Flash de base a écrit 131 lignes pour la tâche triviale, deux à trois fois le reste, ce qui en fait le plus cher en ligne de base, à l'encontre de son propre positionnement.
- L'itération lourde de Sonnet 5 est motivée par la tâche, pas une habitude : 9 appels et $0.09 ici contre 125 appels sur le benchmark.
Voir plus de détails dans l'article LLM Pricing.
Temps de completion & utilisation de tokens
- La prévisibilité des coûts divise les modèles en deux. Les modèles adaptatifs dépensent seulement quand nécessaire (Opus 4.8: 34s de base, 1 072s benchmark) ; les modèles à rythme fixe sont lents et coûteux même sur des travaux triviaux (MiniMax M3: 475 vs 1 684s).
- La longueur de sortie est un trait fixe du modèle, variant de près de 10x pour la même tâche (787 à 7 508 tokens), alimentant directement le coût.
Qu'est-ce qu'un système LLM agentique ?
Construire un logiciel est itératif : écrire du code, l'exécuter, lire les erreurs, les corriger, répéter. Les systèmes d'IA agentique permettent aux LLMs de suivre ce même cycle. Le modèle opère dans un environnement de développement où il peut écrire des fichiers, exécuter des commandes, lire les sorties, et faire des changements basés sur ce qu'il voit, en continuant jusqu'à ce que la tâche soit terminée.
C'est important parce que les applications réelles ne sont pas des fichiers uniques. Elles ont des backends avec des routes et des modèles de base de données, des frontends avec des composants et des appels d'API, des fichiers de configuration, des dépendances, et des tests. Faire fonctionner tout cela ensemble nécessite des tests itératifs et du raffinement, exactement ce que l'architecture agentique permet.
Comment cela fonctionne
Le modèle se trouve dans un harnais avec accès à un shell, un système de fichiers, et les sorties d'exécution. Quand on lui demande de construire une application, il écrit les fichiers de manière incrémentale. Après chaque étape, le harnais montre au modèle ce qui s'est passé : le serveur a-t-il démarré, les tests ont-ils réussi, le linter a-t-il signalé des erreurs ? Sur la base de ce retour, le modèle décide quoi écrire ou corriger ensuite.
Ceci diffère fondamentalement de la génération en un seul coup. Dans les configurations à une seule frappe, le modèle génère une base de code entière à l'aveugle, sans moyen de vérifier si elle fonctionne. Dans les systèmes LLM agentiques, le modèle voit les conséquences de chaque action et corrige le tir. Cependant, cette capacité seule n'est pas suffisante. Le modèle a encore besoin d'un raisonnement solide pour implémenter correctement la logique métier, et c'est là que les différences de performance émergent réellement.
Ajouter comme source préféréeMéthodologie du benchmark des LLM agentiques
Nous avons utilisé Opencode comme harnais d'agent pour tous les modèles et les avons connectés via OpenRouter, à une exception près : Claude Fable 5 a tourné sur la CLI Claude Code avec l'abonnement Claude. Chaque cellule a été exécutée 3 fois pour mesurer la variance par cellule et stabiliser le classement. Nous avons évalué leur capacité à travailler de manière autonome sur 10 tâches de développement logiciel (T-1 à T-10), allant des systèmes de réservation aux tableaux de bord interactifs. Ces tâches exigent que les agents gèrent des projets multi-fichiers et livrent des produits fonctionnels. Les sept alias ajoutés en juillet 2026 (Grok 4.5 et la famille GPT 5.6 : Sol, Terra, Luna, chacun en mode de base et pro) ont tourné sur Opencode 1.15.13 avec les paramètres par défaut de l'API, comme chaque modèle ici ; les chiffres de lancement d'OpenAI pour Sol utilisent des modes de calcul plus élevés.1 Quatre cellules Sol Pro et une cellule Terra Pro se sont terminées par des échecs répétés de flux API silencieux plutôt que par des erreurs de modèle et sont notées comme échecs.
Exécution et orchestration
Chaque agent et tâche commence dans un environnement propre. Les instructions sont fournies sous forme de fichier TASK.md, et nous utilisons un chien de garde de pulsation de 20 minutes pour les scripts de lancement. Pendant cette phase, nous enregistrons les codes de sortie, le temps d'exécution, et si les fichiers backend et frontend ont été créés. Nous suivons également l'utilisation des tokens en temps réel à travers les catégories d'entrée, de sortie et de cache.
Validation du backend : Nous déployons les projets générés dans des environnements isolés pour les tester contre un contrat YAML canonique. La validation couvre les scénarios de chemin heureux, la gestion des erreurs (400/403/409), et la cohérence des données.
Nous testons les résultats en deux modes :
Le mode adaptatif valide la fonctionnalité même avec des noms de route différents, tandis que le mode strict exige l'adhésion exacte au contrat.
Le score global du backend est calculé par cellule comme suit :
backend_overall = has_backend × (0.7 × adaptive_pass_rate + 0.3 × strict_pass_rate)
où has_backend vaut 1 si la cellule a produit un projet backend, 0 sinon. L'adaptatif a un poids plus élevé car il mesure la correction comportementale ; le strict ajoute une pénalité pour la dérive par rapport au contrat (routes renommées, codes de statut substitués, champs de réponse restructurés).
Tests UI et scénarios utilisateur
Nous utilisons l'automatisation de navigateur pour simuler des flux utilisateurs réels, y compris les prévols, le rendu et l'authentification. Nous vérifions les étapes fonctionnelles telles que la soumission de connexion et le comportement post-connexion pour s'assurer que l'application s'exécute sans planter.
Le score UI divise huit étapes en deux groupes. Les étapes d'infrastructure (prévol backend, rendu frontend, formulaire de connexion visible, soumission de connexion, connexion 2xx, pas de crash à l'exécution) mesurent si l'application fonctionne tout court. Les étapes de comportement (signal d'authentification post-connexion, signal de comportement post-connexion) évaluent si l'application remplit sa fonction prévue une fois qu'elle tourne.
ui_score = (behavior_passed / (behavior_passed + behavior_failed)) × (infra_passed / infra_total)
Les étapes de comportement bloquées sont exclues du dénominateur de comportement, de sorte qu'une cellule n'est pas doublement pénalisée lorsque l'application échoue à charger.
Calcul des tokens
Les comptes de tokens sont extraits de la réponse de l'LLM API. Nous soustrayons les tokens d'entrée en cache du total des tokens d'entrée pour obtenir l'entrée effective, qui reflète uniquement les tokens nouvellement traités. Les tokens de sortie ne sont jamais mis en cache, ils restent donc inchangés.
Agrégation finale
Le score final du benchmark est calculé en combinant les résultats des phases précédentes : Final Score = (0.7 × backend_overall) + (0.3 × ui_score) Nous attribuons un poids plus élevé au backend car les échecs de logique au niveau de l'API invalident souvent tout succès dans le frontend.
Exemple de tâche
Tâche 6 : Système de tickets d'assistance
La tâche 6 se concentre sur le développement d'un écosystème de support client complexe. L'objectif principal est de construire une plateforme qui médie la communication entre les clients et les agents de support tout en appliquant strictement les règles métier et les limites de sécurité. Cette tâche évalue la capacité d'un agent à gérer des machines d'état multi-utilisateurs, l'isolation des données et la communication en fil de discussion au sein d'un environnement full-stack.
La tâche demandait de construire un système d'assistance avec :
- Des permissions distinctes pour les Clients (émission/réponse) et les Agents (gestion/résolution).
- Un flux de travail à statut rigide qui empêche les transitions illégales et impose des actions spécifiques au rôle.
- Une isolation avancée des données où les requêtes de ressources non autorisées retournent 404 au lieu de 403 pour protéger l'intégrité du système.
- Un système de réponse chronologique pour une interaction client-agent transparente.
- Un backend FastAPI combiné à un frontend réactif propulsé par Vite (React/Vue/Svelte).
- Une configuration reproductible via des commandes shell spécifiques pour l'activation immédiate du système.
Vous pouvez voir la documentation de la Tâche 6 sur GitHub.
Citez ce benchmark
Choisissez le format qui correspond à votre lieu de publication. Coller la version avec lien dans votre CMS préserve le lien retour.
@misc{kaleliolu2026,
author = {Kalelioğlu, Berk and Dilmegani, Cem},
title = {{A-CODE-LLM Bench: un benchmark de codage agentique}},
year = {2026},
month = jul,
howpublished = {\url{https://aimultiple.com/agentic-llm}},
note = {AIMultiple. Consulté le 10 Juillet 2026}
}Résultats et horodatages de 418 points de données. Téléchargez les données utilisées dans cet article sous forme de fichier ZIP contenant 2 fichiers CSV et un README.
Liens de référence
Soyez le premier à commenter
Votre adresse courriel ne sera pas publiée. Tous les champs sont obligatoires. Les commentaires sont laissés dans leur langue d'origine.