🚀 Agents de code IA : le benchmark vs le modèle (2026)15 min de lecture2 978 mots

🚀 Agents de code IA : le benchmark vs le modèle (2026)

Découvrez le benchmark agents IA : 27 280 exécutions pour comparer coût des modèles, taux de réussite et limites, avant de choisir votre agent de code IA.

agents de code IAbenchmark agents IAcoût des modèles IAharness agentiqueoutils de développement IA
🚀 Agents de code IA : le benchmark vs le modèle (2026)

Agents de code IA : le modèle ne fait pas tout

Choisir un modèle d'IA pour écrire du code ne suffit pas à prévoir ses performances en production. L'agent, lui, pèse tout autant : son environnement d'exécution, ses outils, et la façon dont il déroule une tâche en plusieurs tours. Résultat : le même modèle peut très bien marcher avec un harness, et se révéler cher ou décevant avec un autre. À l'inverse, un agent « bon marché » peut se retrouver mal classé dès qu'on change de modèle.

Pour mesurer ce décalage, un benchmark à grande échelle a comparé l'impact du harness. FrontierHarness Eval v1.1 a testé 22 configurations d'agents avec cinq modèles, sur 62 tâches, avec quatre tentatives par combinaison. Au total : 27 280 exécutions. Et surtout, il n'y a pas un vainqueur valable partout. Les données suggèrent plutôt une règle simple : le choix du harness doit coller au modèle, au budget, et aux tâches que vous visez vraiment.

Voici ce que ce test dit (et ce qu'il ne dit pas) sur le coût des agents de code, la valeur des taux de réussite, et les décisions à prendre avant un déploiement. Les chiffres sont utiles, mais à condition de ne pas leur faire dépasser leur rôle : c'est un benchmark précis, dans un environnement donné, pas une garantie de performance « pour toutes les équipes ».

Comment le benchmark a-t-il été construit ?

FrontierHarness Eval v1.1 cherche à répondre à deux questions très concrètes : est-ce qu'on doit changer d'agent quand on change de modèle ? Et quel couple modèle-agent donne le meilleur compromis entre coût et réussite ? La première version du benchmark comparait neuf harnesses avec un seul modèle. La version 1.1 élargit l'exercice à cinq modèles et 22 configurations d'agents : annoncé à 27 280 exécutions et 83 milliards de tokens traités.

Des configurations comparées dans les mêmes conditions

Les essais portent sur 62 tâches terminales, avec des limites de temps propres à chaque tâche (de 15 minutes à huit heures). Les cinq modèles servis par Baseten sont : GLM-5.3, GLM-5.3 Flash, DeepSeek V4.1 Flash 1017, Muse et Kimi-K3.

Les 22 configurations ne sont pas forcément 22 « familles » totalement indépendantes. Certaines variantes d'un même outil sont comptées séparément : quatre profils DeepSeek Harness utilisent des ensembles d'outils différents, et OpenCode est évalué en deux versions. Ce point compte : les résultats concernent des configurations précises, pas seulement des marques ou des intitulés.

Chaque harness a été lancé avec ses réglages par défaut, au niveau maximal de raisonnement, et avec les mêmes réglages pour chaque modèle. C'est utile pour représenter un usage « tout venant », mais ça ne répond pas à une autre question : que se passerait-il avec une configuration finement optimisée pour un modèle donné ?

Chaque essai a tourné dans un environnement Runta distinct, supprimé à la fin. Du coup, un essai ne pouvait pas réutiliser les fichiers d'un autre. Les traces ont aussi été auditées : 216 exécutions ont été signalées pour « reward hacking », dont 163 liées à des recherches en ligne. Ces cas ont reçu un score nul.

Deux façons de regarder le rapport coût-résultat

Le benchmark distingue deux indicateurs. Le coût moyen par tâche est calculé en moyennant les essais tarifés de chaque tâche, puis en faisant la moyenne sur les tâches. Le coût par réussite divise ce coût moyen par le taux de réussite. Le premier sert surtout à comparer les dépenses ; le second à repérer les meilleurs compromis.

Cette séparation évite un piège classique : confondre un agent « moins cher » parce qu'il échoue souvent, et un agent plus coûteux mais qui aboutit davantage. Cela dit, l'incertitude reste là : quatre tentatives par tâche et par configuration, c'est peu pour couvrir tous les usages possibles.

Pourquoi le meilleur agent dépend-il du modèle ?

Le résultat le plus important est simple : le meilleur rapport coût/taux de réussite change selon le modèle. Codex CLI arrive en tête avec GLM-5.3 ; Pi avec GLM-5.3 Flash ; ZCode avec DeepSeek ; Oh My Pi avec Muse ; Alma avec Kimi-K3. Donc, dans ces données, aucun harness ne gagne « en général ».

Le classement par coût bouge lui aussi. En moyenne, un harness médian change d'environ 11 places sur 22 selon le modèle. Codex CLI passe de la première place avec GLM-5.3 à la seizième avec Kimi-K3. DeepSeek Harness: Creator passe de la première place avec Muse à la vingt-et-unième avec GLM-5.3 Flash. OpenCode v1 est le moins cher avec DeepSeek, mais seulement treizième avec Muse.

Le coût n'est pas une caractéristique fixe de l'agent

On pourrait croire que, à peu près, un agent conserve son rang de coût quand on change de modèle. Les mesures montrent l'inverse. Les appels, la longueur des trajectoires, la mise en cache, et les prix propres à chaque modèle s'entrechoquent. Le prix du modèle fixe largement le niveau global de la facture, mais ne suffit pas à classer les harness.

Une analyse à deux facteurs attribue 92,8 % de la variation du coût au modèle, 2,3 % à un effet « harness » commun, et 4,9 % à l'interaction entre modèle et harness (avec un peu de bruit). Autrement dit, une grosse partie des différences d'un agent à l'autre ne reste pas stable quand on change de modèle.

Les auteurs vérifient aussi que ces écarts ne viennent pas juste de la variabilité aléatoire : sur deux moitiés des essais, les classements de coût ont une corrélation moyenne de 0,71 quand le modèle est identique, contre 0,26 quand les modèles diffèrent. C'est un indice solide d'un effet réel du couple modèle-agent, sans pour autant rendre chaque rang « universel ».

Même « meilleur compromis » = pas une règle unique

Le benchmark choisit le meilleur compromis en se basant sur le coût par réussite, avec une règle d'arbitrage précise : un harness peut être préféré s'il coûte jusqu'à 30 % de plus par réussite, tout en apportant au moins cinq points de taux de réussite. Cette règle explique par exemple le choix de ZCode plutôt que d'OpenCode v1 avec DeepSeek, et celui d'Alma plutôt que d'Oh My Pi avec Kimi-K3.

Elle est logique si vous accordez de la valeur à une hausse nette du taux de réussite. Mais une équipe qui cherche d'abord le coût minimal, ou qui tolère davantage d'échecs sur des tâches non critiques, peut faire un choix différent. Le « meilleur » agent reste donc lié à votre façon de décider.

Que révèle le benchmark sur le coût réel ?

Quand on fixe le modèle, le coût par tâche du harness le plus cher est entre 1,8 et 5 fois plus élevé que celui du moins cher, selon le modèle. L'écart maximal apparaît avec DeepSeek : Cline CLI coûte cinq fois plus que OpenCode v1, pour seulement deux points de réussite supplémentaires. Pour les autres modèles, l'écart reste bien plus contenu : le harness le moins cher est à 0,4 point au plus derrière le plus cher.

Ces écarts paraissent plus marqués que ceux observés lors de tests où l'on permute les essais entre harness. Dans ces simulations de hasard, les ratios vont de 1,2 à 1,8 ; les cinq ratios réels dépassent toutes les simulations, avec une valeur p de 0,003. L'idée à retenir : ce n'est pas uniquement du bruit de relances. Par contre, ça ne garantit pas que les mêmes écarts se retrouveront ailleurs, sur d'autres tâches, ou chez un autre fournisseur.

Plus cher ne veut pas dire « plus performant »

Les corrélations entre coût par tâche et taux de réussite vont de −0,39 à +0,22 selon le modèle. Donc, on ne voit pas de relation générale « ça coûte plus cher donc ça réussit plus ». Pour quatre des cinq modèles, le harness le plus coûteux par réussite affiche même un taux de réussite plus faible que le moins coûteux par réussite.

Le meilleur taux de réussite global atteint 61,9 %, mais plusieurs agents moins chers restent proches. Sur la « frontière » coût-performance, on trouve OpenCode v2, Pi, Codex CLI et ZCode : aucun autre harness ne les domine à la fois sur le coût et la réussite. Les autres configurations coûtent jusqu'à 1,6 fois plus cher, avec des taux entre 50,6 % et 60,2 %.

La précision statistique oblige quand même à être prudent. En rééchantillonnant 62 tâches et en répétant l'exercice 4 000 fois, Codex CLI reste en tête avec GLM-5.3 dans 99,6 % des tirages. Les autres gagnants sont moins nets : Oh My Pi avec Muse sort gagnant dans 53 % des tirages, ZCode avec DeepSeek dans 47 %, Pi avec GLM-5.3 Flash dans 42 % et Alma avec Kimi-K3 dans 25 %. Pour ces couples, plusieurs options sont proches ; quelques points d'écart ne suffisent pas à trancher avec certitude.

Une grosse partie de la facture vient des échecs

Au total, 64,5 % du coût des essais évalués correspond à des tentatives qui n'aboutissent pas : 52,7 % à des échecs, et 11,8 % à des expirations de délai. C'est un point important pour la budgétisation : regarder uniquement le coût par appel ou le coût d'une tâche réussie ne donne pas la vue d'ensemble.

Le coût « pertinent », c'est celui de la boucle complète : essais réussis, échecs, nouvelles tentatives et abandons. Même sur les cinq agents au meilleur rapport qualité-prix, les essais échoués représentent encore 60 à 69 % du coût de chaque configuration. Réduire le prix des tokens aide, mais éviter les trajectoires infructueuses peut avoir un effet plus direct sur la facture finale.

Quels choix techniques font la différence ?

L'étude compare quatre facteurs : la taille de la première requête, le nombre d'outils proposés, le taux de mise en cache et le nombre d'étapes. Dans ces données, les trois premiers ne prédisent pas vraiment le coût par réussite : les corrélations de rang se situent entre −0,03 et +0,02. En revanche, le nombre d'étapes a une relation plus nette avec le coût (corrélation +0,51, valeur p de 0,015).

Ce résultat colle assez bien à la logique d'un agent : à chaque étape, il renvoie une partie du contexte au modèle. En moyenne, les traces montrent entre deux et 4,8 millions de tokens d'entrée consommés selon le harness. Même si la première requête atteint 21 365 tokens, elle reste en dessous de 1 % de cette consommation totale.

Réduire les boucles inutiles avant de toucher au prompt

Un prompt de départ compact ne rend donc pas automatiquement un agent économique. mini-SWE-agent, par exemple, a la plus petite première requête (882 tokens), mais il lui faut 38 étapes par réussite et il finit 17e sur 22 pour le coût par réussite. Le coût ne se décide pas uniquement au lancement : il s'accumule au fil des échanges.

Pour une équipe qui développe un agent, le levier prioritaire est souvent de réduire les étapes superflues : appels d'outils redondants, vérifications répétées, absence de critère d'arrêt ou corrections qui repartent de zéro. L'objectif n'est pas de supprimer toute vérification ; une étape de contrôle peut éviter une erreur coûteuse. La différence se fait surtout entre le contrôle utile et la boucle improductive.

La mise en cache reste importante, mais elle ne suffit pas à expliquer les résultats. Selon les modèles, un token d'entrée mis en cache coûte entre 2 % et 20 % du prix d'un token d'entrée non mis en cache. Sur l'ensemble des coûts, les tokens en cache représentent 42 %, les tokens de sortie 33 % et le reste des tokens d'entrée 25 %. Donc, le cache baisse bien la facture, mais il ne compense pas la répétition du contexte quand l'agent fait trop d'allers-retours.

Des motifs communs, mais pas une preuve de causalité

Dans les traces des cinq harness les mieux classés, on retrouve trois motifs. D'abord, un outil de terminal concentre 61 à 93 % des appels d'outils. Ensuite, ces agents réutilisent largement le contexte entre requêtes, ce qui aide la mise en cache. Enfin, ils utilisent peu les sous-agents et les résumés : chacun des cinq a recours à un sous-agent dans au plus six essais.

Attention toutefois : ce sont des observations, pas une démonstration que ces choix produisent forcément les meilleurs résultats. Le benchmark n'isole pas chaque caractéristique dans un protocole contrôlé. Une équipe ne devrait donc pas supprimer les sous-agents ou les résumés « par principe » : ces mécanismes peuvent être utiles sur des tâches longues, parallélisables, ou contraintes par une fenêtre de contexte limitée.

Un autre signal concerne la gestion des échecs. Parmi les essais non réussis des meilleurs harness, 68 à 82 % se terminent par une réponse finale « assurée » plutôt que par une expiration de délai. Peu indiquent clairement que le travail est incomplet. Une vérification avant arrêt pourrait réduire certaines réponses trompeuses, mais l'effet exact sur le taux de réussite et le coût reste à mesurer.

Comment choisir un agent pour son équipe ?

Ce benchmark ne permet pas de choisir « un outil universel » pour toutes les entreprises. Il porte sur des modèles ouverts, sur un fournisseur d'inférence unique, des prix précis et un ensemble de 62 tâches. Des modèles propriétaires, un autre fournisseur ou des tâches internes peuvent changer les classements. Et pour un produit européen, il faut aussi intégrer les contraintes de localisation des données, de sécurité et de conformité RGPD, qui ne sont pas évaluées ici.

En pratique, la bonne décision consiste à reprendre la méthode sur un échantillon représentatif de votre propre travail. Un outil destiné à corriger des tickets simples ne devrait pas être jugé uniquement sur des tâches longues de terminal. De la même façon, le taux de réussite d'un assistant qui propose un correctif à valider par un développeur ne pèse pas de la même façon que celui d'un agent autorisé à modifier directement un dépôt de production.

Une procédure de comparaison applicable

  1. Définissez les tâches et le niveau de risque. Constituez un jeu de cas représentatifs : corrections de bogues, tests, refactorisations, tâches d'exploitation. Séparez les opérations réversibles des actions sensibles.
  2. Fixez les conditions avant le test. Gardez les mêmes consignes, limites de temps, accès aux fichiers et critères de validation pour chaque couple modèle-agent. Utilisez les réglages qui reflètent votre usage réel.
  3. Mesurez le coût d'une tâche terminée. Comptez essais échoués, expirations, relances et temps de revue humaine. Le coût par appel ne reflète pas le coût opérationnel complet.
  4. Répétez les essais. Quelques résultats isolés peuvent venir du hasard. Rejouez suffisamment de tâches pour distinguer une tendance d'une variation faible et incertaine.
  5. Choisissez selon les conséquences métier. Si un échec est peu coûteux, un agent moins cher peut suffire. Si une correction erronée crée un incident ou un risque de sécurité, privilégiez un taux de réussite vérifié et une validation humaine adaptée.

Cette démarche évite deux erreurs fréquentes : sélectionner le modèle uniquement sur son prix affiché, ou adopter un harness « populaire » sans tester son comportement avec le modèle retenu. Elle permet aussi de relancer le test si un fournisseur modifie ses prix, son cache ou la version d'un modèle.

Conclusion

Le principal enseignement de FrontierHarness Eval v1.1 n'est pas qu'un agent serait « le meilleur » dans l'absolu. C'est plutôt que le modèle et le harness forment un couple : il faut mesurer ensemble le coût et la performance. Le modèle explique une grosse partie du niveau général des coûts, mais le choix du harness peut encore faire varier la facture jusqu'à un facteur cinq, à modèle fixé.

Pour une équipe, le prochain pas est simple et concret : tester les agents candidats sur un jeu de tâches représentatif, compter les échecs et les relances, puis comparer le coût par réussite avec le niveau de risque acceptable. Ce n'est pas un classement spectaculaire. C'est ce qui sert vraiment quand on doit décider pour de la production.

Questions frequentes

Pas automatiquement, mais il faut le réévaluer. Les classements de coût changent nettement selon le modèle. Comparez les configurations candidates sur vos tâches, avec des critères identiques, avant de conserver ou de remplacer votre agent.
Il n’y a pas de réponse universelle. OpenCode v2 est le moins coûteux par tâche en agrégeant les modèles, mais le classement varie selon le modèle. Codex CLI passe notamment de la première place avec GLM-5.3 à la seizième avec Kimi-K3.
Cela dépend du coût d’un échec. Le benchmark ne constate pas de relation générale entre prix et réussite. Si l’échec est coûteux, quelques points supplémentaires peuvent compter ; s’il est facile à corriger, une option moins chère peut suffire.
Chaque étape peut renvoyer une grande partie du contexte au modèle. Les appels répétés accumulent ainsi des tokens d’entrée, même si la requête initiale est courte. Dans ce benchmark, le nombre d’étapes est davantage associé au coût par réussite que la taille du prompt initial.
Pas directement. Le test porte sur cinq modèles servis par un seul fournisseur et sur ses prix et mécanismes de cache. Les modèles propriétaires ou un autre fournisseur peuvent modifier les coûts et les classements ; un test sur vos propres tâches reste nécessaire.

Articles similaires