Meilleure IA pour coder ? Quel modèle pour quelle tâche

Quels modèles sont haut de gamme, milieu de gamme et entrée de gamme chez chaque fournisseur ?

Quand vous choisissez le modèle d’un agent de codage, vous choisissez deux choses à la fois : le modèle lui-même et combien il réfléchit. Nous avons traité la seconde, l’effort, dans l’article précédent, et la lecture des scores de benchmark dans l’article sur SWE-bench. Cet article s’intéresse au modèle lui-même : ce qu’il vaut pour coder, ce qu’il coûte par tâche et comment le choisir dans cinq outils. Nous avons classé les modèles de chaque fournisseur en trois gammes :

Source : pages des modèles et des tarifs des trois fournisseurs (Anthropic, OpenAI, Google), 20 octobre 2026. Prix par MTok en entrée / sortie, niveau standard ; chez OpenAI pour les prompts jusqu’à 272K tokens, chez Anthropic pour les prompts de Haiku 5.5 jusqu’à 100K tokens. La seconde phrase de chaque cellule est la description du fournisseur lui-même.

Chez Anthropic, il existe encore un modèle au-dessus d’Opus : Fable 5.1. Anthropic le présente comme son modèle le plus capable ouvert à tous les clients ; son prix est de $10 en entrée et $50 en sortie par MTok. Dans le tableau, nous avons tout de même placé Opus 5.5 en haut de gamme chez Anthropic, car Anthropic recommande de commencer la plupart des travaux avec Opus.

Les prix catalogue font apparaître une égalité : Sonnet 5.5, GPT-6.1 Sol et Gemini 4 Argon demandent tous trois aujourd’hui $2 en entrée et $10 en sortie par MTok, et Haiku 5.5 et GPT-6 Luna sont eux aussi au même prix. En revanche, chacun des prix par token d’Opus 5.5 est le double de celui de Sonnet 5.5, et ceux d’Astra valent cinq fois ceux de Sol. Mais un même prix par token ne donne pas un même coût par tâche : un modèle peut avoir besoin de plus d’étapes pour finir le même travail. Nous le montrons, mesures à l’appui, dans la section suivante.

Dans les longues sessions d’agent, trois seuils changent le prix. Sur Haiku 5.5, toute requête dont le prompt dépasse 100K tokens coûte 5 fois plus cher ($0,50 / $2,50), et les tokens lus depuis le cache comptent aussi dans ce total. Chez OpenAI, une requête de plus de 272K tokens coûte deux fois plus cher en entrée et 1,5 fois plus cher en sortie. Chez Google, le seuil est une date : le prix d’Argon double le 1er décembre, celui de 3.8 Flash le 1er janvier 2027.

Dans une session d’agent, l’essentiel de la facture vient des tokens lus depuis le cache ; Anthropic écrit d’ailleurs qu’ils représentent la plus grande part du coût du travail agentique et de codage. Pour la lecture en cache, Opus 5.5 demande $0,20 par MTok, Sonnet 5.5 $0,10 et Haiku 5.5 $0,01. Quand le prompt dépasse 100K tokens, le prix de Haiku passe à $0,05, et l’écart avec Sonnet tombe de dix fois à deux fois. C’est pourquoi l’avantage de prix de l’entrée de gamme fond à mesure qu’une session s’allonge.

Que vaut chaque modèle pour coder, et combien coûte-t-il ?

Les grilles tarifaires sont exprimées par token, mais ce qui compte pour vous, c’est le coût d’un travail terminé. La documentation d’Anthropic recommande d’ailleurs de comparer les modèles au coût par tâche accomplie, et non par token. Nous avons donc regardé deux types de mesures : un index indépendant qui mesure chaque modèle dans son propre outil de codage, et les mesures des éditeurs eux-mêmes. Les résultats déclarés par un éditeur sont signalés comme tels.

Le Coding Agent Index d’Artificial Analysis ne mesure pas un modèle seul, mais dans un outil de codage : les modèles Claude tournent dans Claude Code, ceux d’OpenAI dans Codex, ceux de Gemini dans Antigravity. Il compte 303 tâches issues de trois benchmarks, et chaque tâche fait l’objet de 3 essais. Le coût est calculé aux prix de l’API, pas sur un abonnement. Pour chaque famille, nous avons retenu les lignes des modèles haut de gamme, milieu de gamme et entrée de gamme ; chez Anthropic, nous avons ajouté la ligne de Fable 5.1 :

Le graphique n’est pas un classement : les lignes ont été mesurées à des niveaux d’effort différents, et l’index n’a mesuré certains modèles qu’à un seul niveau. En le lisant, regardez trois choses :

• Dans deux familles, le milieu de gamme se rapproche du haut de gamme. Dans Codex, GPT-6.1 Sol a obtenu 61,4 points en medium et GPT-6 Astra 61,6 en max ; par tâche, $0,70 et $7,47, pour 11 et 29 minutes. Dans Claude Code, les deux modèles ont été mesurés en max : Sonnet 5.5 a obtenu 68,4 points et Opus 5.5 66,0, pour $14,19 et $13,04 par tâche. Fable 5.1, qui se situe encore au-dessus d’Opus, n’a devancé aucun des deux en max, avec 62,2 points.
• Des tokens bon marché ne font pas une tâche bon marché. Le prix par token de Sonnet 5.5 est la moitié de celui d’Opus, mais en max il a bouclé une tâche en 266 étapes et 87 minutes en moyenne ; Opus, en 155 étapes et 64 minutes. L’inverse arrive aussi : les prix d’entrée et de sortie de Fable 5.1 sont deux fois et demie ceux d’Opus, mais en max il a bouclé une tâche en 37 étapes et 35 minutes en moyenne, et à $12,39 par tâche il est revenu un peu moins cher qu’Opus. Gemini 3.8 Flash a fait en moyenne 188 étapes par tâche ; à $2,47 par tâche, il est revenu plus cher que Sonnet 5.5 en high ($1,24).
• L’effort fait aussi une grande différence au sein d’un même modèle. En high, Sonnet 5.5 a obtenu 55,0 points, pour $1,24 et 12 minutes par tâche. Nous avons comparé les niveaux un par un dans l’article sur l’effort. La documentation d’Anthropic écrit aussi que régler l’effort est souvent un meilleur levier que changer de modèle.

Le graphique a deux limites. L’index n’a mesuré Opus 5.5 et Fable 5.1 qu’en max ; il n’existe aucune mesure indépendante en medium, le réglage par défaut d’Opus dans Claude Code. Par ailleurs, quand un modèle refuse pour des raisons de sécurité, un autre modèle peut terminer l’essai, et l’essai compte quand même : sur 909 essais, un autre modèle en a terminé 78 dans la ligne Opus 5.5 max, 74 dans la ligne Fable 5.1 max et 45 dans la ligne Sonnet 5.5 max. L’index ajoute en outre la mention « with fallback » (avec modèle de secours) à la ligne de Fable.

Un écart de quelques points peut aussi être du bruit. Dans le classement de Terminal-Bench 4.0 lui-même, Opus 5.5 (max) dans Claude Code obtient 64,85 % ± 3,11 et Sonnet 5.5 (max) 61,82 % ± 2,94 ; chaque ligne repose sur 330 essais. Dans la composante qu’Artificial Analysis tire du même benchmark, l’ordre est inversé : Sonnet 5.5 66,2, Opus 5.5 63,1. Un écart de trois points entre ces deux modèles ne dit donc pas lequel est le meilleur. Anthropic écrit aussi qu’à ce niveau de capacité, les écarts de benchmark sont un guide moins fiable des différences réelles ; Epoch AI, de son côté, a jugé Terminal-Bench 4.0 défaillant. Nous avons expliqué comment lire un score dans l’article sur SWE-bench.

Quand un modèle haut de gamme vaut-il son prix ?

La question est la même dans les trois familles : quand le modèle haut de gamme rentabilise-t-il son prix par token plus élevé ? Dans les mesures dont nous disposons, le milieu de gamme, à un réglage un peu plus élevé, rattrape le haut de gamme dans deux familles, mais pas dans la troisième. Pour chaque famille, nous avons mis côte à côte les deux mesures les plus proches du haut et du milieu de gamme :

La mesure d’Anthropic est l’exemple le plus net. D’après le document, chacun des prix par token d’Opus 5.5 est le double de celui de Sonnet 5.5, mais Opus en low résout autant de tâches que Sonnet à son réglage par défaut, pour seulement 7 % de plus par tâche résolue. Faites tourner Opus à son propre réglage par défaut, medium, et le taux de résolution passe à 92,8 % pour un coût de $0,22 : pour environ cinq points de plus, vous payez deux fois plus par tâche résolue. C’est la mesure de l’éditeur sur un sous-ensemble de SWE-bench Pro, et elle ne se compare pas au classement public.

Monter d’un cran au-dessus d’Opus n’a pas rapporté de points dans ce tableau. Au réglage par défaut de Fable 5.1, high, le taux de résolution sur une seule exécution est de 92,3 % et le coût par tâche résolue de $1,19. Anthropic y voit le même résultat qu’Opus en medium, aux variations d’une exécution à l’autre près ; Fable n’a donc pas battu Opus sur cet ensemble, et il a coûté environ cinq fois plus par tâche résolue. Le document précise aussi que les deux modèles atteignent en grande partie le plafond sur cet ensemble.

Où Opus gagne-t-il ses cinq points de plus ? Anthropic et Google donnent la même réponse : sur le travail complexe, long et en plusieurs étapes. Anthropic recommande Opus 5.5 pour le codage autonome qui dure des heures et les gros refactorings, et Sonnet 5.5 pour le codage du quotidien ; l’annonce de Sonnet 5.5 écrit aussi qu’Opus reste nettement plus fort sur le travail ouvert qui demande un jugement soutenu. Le chemin que recommande Anthropic pour Fable 5.1 commence lui aussi par Opus : si Opus ne suffit pas, même en xhigh ou en max, sur un raisonnement exigeant ou un travail agentique de longue haleine, passez à Fable. Google recommande Gemini 4 Argon pour le génie logiciel complexe et le raisonnement, et sa page de tarifs indique qu’il est conçu pour les agents autonomes en plusieurs étapes. OpenAI place la limite ailleurs : il présente GPT-6.1 Sol comme le modèle qui offre des performances proches d’Astra pour un coût plus bas, et la documentation de Codex recommande de commencer par Sol même pour un travail ambigu en plusieurs étapes ; il réserve Astra au cas où le coût et la latence n’importent pas. Le document d’Anthropic sur les coûts donne aussi un critère : comparez les modèles non sur la tâche typique de votre travail, mais sur son dixième le plus difficile, car la facture se joue sur les tâches que le modèle le moins cher rate.

La famille Google se présente autrement. Dans l’index indépendant, 3.8 Flash ne s’est pas approché du score d’Argon ; mais les deux modèles ont été mesurés dans des outils différents (Argon dans Antigravity CLI, Flash dans le SDK Antigravity). GitHub Copilot range d’ailleurs 3.8 Flash dans le même groupe que Haiku 5.5 et GPT-6 Luna, celui de l’aide rapide pour les tâches simples ou répétitives. Au vu de ces deux sources, le milieu de gamme de Google se rapproche plutôt de l’entrée de gamme dans un agent de codage.

Les réglages par défaut des outils ne suivent pas toujours ces recommandations :

• Claude Code démarre avec Opus 5.5 sur les forfaits Pro, Max, Team et Enterprise depuis le 22 septembre (version 2.1.280), et démarre aussi avec Opus 5.5 sur l’API. Pourtant, sa propre page sur les coûts dit que Sonnet fait bien la plupart des tâches de codage et qu’il vaut mieux garder Opus pour les décisions d’architecture complexes et le raisonnement en plusieurs étapes ; elle attribue aussi les factures anormalement élevées surtout à Opus laissé par défaut. Autre détail : dans Claude Code, Opus 5.5, Sonnet 5.5 et Haiku 5.5 démarrent avec un effort medium, alors que dans la mesure d’Anthropic ci-dessus, le réglage par défaut de Sonnet est high. Si vous passez à Sonnet, montez aussi l’effort à high.
• Dans Codex, le modèle par défaut est GPT-6.1 Sol, un modèle milieu de gamme.
• Dans GitHub Copilot, vous choisissez le modèle dans le sélecteur ou avec Auto ; nous décrivons Auto plus bas.
• Dans Cursor, le forfait Plus ne donne accès qu’aux modèles de Cursor lui-même. Les modèles Claude, GPT et Gemini s’utilisent à partir de Premium, au prix catalogue de l’API, payés sur un crédit chargé à l’avance.
• Dans Antigravity, l’offre gratuite et Google AI Plus ne proposent, côté Gemini, que 3.8 Flash ; Gemini 4 Argon, Claude Sonnet 5.5 et Opus 5.5 demandent un abonnement Google AI Pro hors période d’essai, ou supérieur.

Sur abonnement, le haut de gamme consomme votre limite plus vite. Codex est le seul outil à l’exprimer en nombre de messages par modèle : selon sa page de tarifs, le nombre estimé de messages locaux sur une fenêtre de cinq heures avec le forfait Plus est de 5–45 avec GPT-6 Astra, 15–160 avec GPT-6.1 Sol et 350–3 000 avec GPT-6 Luna. Dans les autres outils :

• Claude : la page des forfaits indique que ce que vous pouvez utiliser dépend du modèle choisi, sans donner de ratio. Claude Code affiche des messages de limite distincts pour Opus et Sonnet ; quand vous en atteignez un, vous pouvez passer à l’autre famille et continuer à travailler.
• GitHub Copilot : depuis le 1er juin 2026, l’utilisation est calculée par token, au prix API de chaque modèle. Un modèle deux fois plus cher consomme aussi vos crédits IA deux fois plus vite pour le même nombre de tokens.
• Cursor : le pool hebdomadaire couvre les modèles de Cursor lui-même, et chaque modèle puise dans le pool à un rythme différent ; les modèles tiers se paient sur le crédit, pas sur le pool.
• Antigravity : les modèles Gemini d’une part, les modèles Claude et GPT de l’autre puisent dans des limites distinctes, sur cinq heures et à la semaine.

Peut-on coder avec un modèle d’entrée de gamme ?

Comme agent principal, d’après les données disponibles, non ; comme appoint, oui. L’annonce de Haiku 5.5 par Anthropic le dit elle-même : pour le codage agentique complexe, Sonnet 5.5 et Opus 5.5 sont les meilleurs choix ; Haiku 5.5 les complète bien comme sous-agent dans le travail de codage et assure de façon fiable des tâches comme les résumés, la compaction et la classification. Dans le tableau de la même annonce, Haiku 5.5 obtient 39,2 % sur Terminal-Bench 4.0, Sonnet 5.5 70,6 % et GPT-6 Luna 16,4 % (selon Anthropic).

L’index indépendant montre aussi où se situe l’écart. Sur les tâches DeepSWE, où le modèle écrit du code dans Claude Code, Haiku 5.5 est resté entre 45,4 et 49,0 à tous les niveaux d’effort, et Sonnet 5.5 entre 61,9 et 72,0 ; augmenter l’effort n’a pas comblé cet écart. Sur SWE-Atlas-QnA, où le modèle répond à des questions sur une base de code, l’écart est faible : Haiku 5.5 a obtenu 51,6 en xhigh et Sonnet 5.5 44,9 en medium. L’entrée de gamme est la plus en retard quand il s’agit d’écrire du code, et la moins en retard quand il s’agit de lire du code et de répondre à des questions dessus.

Qu’il soit bon marché par tâche n’est vrai qu’à moitié. En medium, Haiku 5.5 a coûté $0,23 par tâche, mais il a bouclé une tâche en 14 minutes et 44 étapes en moyenne ; Sonnet 5.5 en low : $0,48, 6 minutes et 19 étapes. Le score de Haiku est aussi plus bas : 33,6 contre 42,1. Le modèle le plus rapide d’Anthropic s’est montré plus lent par tâche.

Les deux autres familles placent leur entrée de gamme au même endroit. La documentation de Codex recommande GPT-6 Luna pour des agents rapides au périmètre étroit, chargés d’un travail clair, répétitif ou à gros volume ; dans le classement de Terminal-Bench 4.0, Luna en max dans Codex obtient 16,36 % ± 2,72. Google présente Gemini 3.5 Flash-Lite comme un modèle à faible latence et à faible coût pour les tâches de sous-agent et l’analyse de documents.

Dans Claude Code, le sous-agent intégré Explore, qui fouille la base de code, est arrivé avec la version 2.0.17 (15 octobre 2025) et tournait sur Haiku ; depuis la version 2.1.198 (1er juillet), il tourne avec le modèle de la session principale. Si vous voulez confier la recherche à un modèle d’entrée de gamme, c’est donc à vous de le configurer. Voici comment dans cinq outils :

Source : documentation et notes de version de chaque outil, 20 octobre 2026.

Voici un exemple de définition pour Claude Code. Quand le champ name vaut Explore, elle remplace l’agent intégré ; limiter ses outils à la lecture garde aussi sa tâche étroite :

---
name: Explore
description: Cherche et lit dans la base de code, ne modifie aucun fichier
tools: Read, Glob, Grep
model: haiku
---
Trouve le code demandé. Écris un rapport court :
chemin du fichier, ligne et une phrase d’explication.

Un avertissement : à mesure qu’un sous-agent de recherche lit de gros fichiers, son prompt grossit. Sur Haiku 5.5, toute requête de plus de 100K tokens coûte 5 fois plus cher ; gardez donc le rapport du sous-agent court et les fichiers qu’il lit peu nombreux. Nous avons expliqué le fonctionnement des sous-agents dans l’article sur les sous-agents.

Le mode Auto ou l’usage de deux modèles apporte-t-il quelque chose ?

Il existe des moyens de laisser l’outil choisir le modèle, ou de faire travailler deux modèles ensemble. La règle qui ressort des mesures d’Anthropic est simple : avant d’ajouter un second modèle, réglez l’effort du modèle unique, car la plupart des travaux s’arrêtent là ; ne montez un dispositif à deux modèles que s’il bat la courbe score-coût du modèle seul sur tous ses niveaux d’effort.

L’Auto de GitHub Copilot est disponible sur tous les forfaits. Dans VS Code, Copilot CLI et l’application Copilot, il a trois niveaux : Efficiency, Balance et Intelligence. Le niveau change le modèle auquel va une requête ; vous payez toujours le prix du modèle choisi par Auto, avec 10 % de remise sur les forfaits payants. Copilot indique de quel modèle vient chaque réponse, et la CLI l’affiche dans le terminal. Sur les forfaits individuels, Auto peut aussi utiliser des modèles en cours d’évaluation ; vous pouvez le désactiver.

L’Auto de Cursor dépend du forfait. D’après la page de tarifs, le forfait Plus n’a pas d’Auto ; les autres forfaits individuels n’ont que le mode Cost, et quel que soit le modèle qui répond, la requête puise dans le pool hebdomadaire comme un modèle de Cursor. Les modes Balance et Intelligence sont réservés à Teams et Enterprise ; là, une requête se paie au prix catalogue du modèle vers lequel elle a été routée, et le modèle qui a répondu est masqué par défaut. La page Router de Cursor écrit pourtant que tous les modes Auto se paient au prix catalogue du modèle choisi par le routage ; le 20 octobre 2026, les deux pages ne concordaient pas.

La documentation des modèles de Claude Code, de Codex et d’Antigravity ne décrit pas d’Auto qui choisisse un modèle par requête. Gemini CLI a un Auto, qui choisit le modèle selon la complexité de la tâche ; le 18 juin 2026, Google a remplacé Gemini CLI par Antigravity CLI pour les utilisateurs de l’offre gratuite et de Google One, et recommande Antigravity pour Gemini 4 Argon.

opusplan est un réglage de modèle de Claude Code qui répartit le travail entre deux modèles : Opus en mode plan, Sonnet pour l’exécution. Comme chaque modèle garde son propre cache, chaque entrée ou sortie du mode plan compte comme un changement de modèle et le cache repart de zéro ; sur une longue session, cela se voit sur la facture.

Advisor permet au modèle, dans Claude Code, de consulter un second modèle plus fort aux moments clés : avant de s’engager dans une approche, quand il bute sur la même erreur, avant de terminer le travail. Il fonctionne sur abonnement comme sur l’API. Dans la mesure d’Anthropic avec les modèles actuels, le seul duo qui consultait souvent a obtenu 1,7 point de plus que le modèle seul sur un benchmark de codage ; cet écart est à la limite des variations d’une exécution à l’autre, et le coût est environ 2,1 fois plus élevé. Quand le modèle consultait rarement, le duo a fait jeu égal avec le modèle seul, ou moins bien.

Un modèle local peut-il remplacer ces modèles ?

En l’état actuel des données, aucune mesure ne montre qu’il le peut comme agent principal. Les classements indépendants mesurent aussi des modèles à poids ouverts, mais ceux dont la taille est connue relèvent de la classe serveur : GLM-5.3-Flash, par exemple, compte 320 milliards de paramètres (dont 18 milliards actifs pour chaque token) et obtient, sur Terminal-Bench 4.0 dans Claude Code, 35,76 % ± 3,54. Nous n’avons trouvé aucune mesure indépendante comme agent de codage pour un modèle qui tient manifestement sur un ordinateur portable.

Le matériel pose aussi une limite. Ollama règle la fenêtre de contexte selon la VRAM : sous 24 Gio, le contexte par défaut est de 4K tokens. Pour les outils de codage, il recommande pourtant au moins 64 000 tokens, et le besoin en mémoire grandit avec le contexte. Google recommande de son côté, pour Gemma 4 26B A4B, au moins 24 Go de VRAM ou de mémoire unifiée. Voici comment un modèle local se branche dans cinq outils :

Source : documentation des outils et d’Ollama, 20 octobre 2026. Ollama demande aussi au moins 64K de contexte pour Claude Code et Codex.

Choisir un modèle local ne veut pas dire que votre code ne quittera pas la machine. La note de GitHub le dit clairement : choisir un modèle local n’active pas le mode hors ligne et ne désactive pas la télémétrie de GitHub ; dans la CLI, vous activez le mode hors ligne séparément avec COPILOT_OFFLINE=true. Dans Cursor, les requêtes passent par les serveurs de Cursor pour que le prompt final y soit construit. Si votre code ne doit pas quitter la machine, vérifiez tout le trajet de l’outil, pas seulement le modèle.

L’endroit le plus raisonnable pour essayer un modèle local, c’est le travail des modèles d’entrée de gamme : recherche dans une base de code, résumés, classification, soit des tâches fondées sur la lecture et dont le résultat se vérifie. Faites-le là aussi en mesurant sur vos propres tâches ; les mesures indépendantes ci-dessus ne couvrent pas les modèles de cette taille.

Quel modèle choisir pour quel travail ?

Ce que les données ont en commun : le milieu de gamme suffit pour la plupart des travaux, le haut de gamme fait la différence sur un travail long et ambigu, et l’entrée de gamme reste bon marché comme appoint. Pour les travaux courants, voici les modèles correspondants dans les trois familles :

Les raisons derrière les cartes sont plus haut. Le milieu de gamme pour le travail courant, parce que dans la mesure d’Anthropic, Sonnet à son réglage par défaut a résolu autant de tâches qu’Opus en low, et que dans l’index indépendant, Sol en medium a rejoint le score d’Astra en max. Dans la famille Google, Argon aussi pour le travail courant, parce que dans la mesure indépendante, 3.8 Flash ne s’en est pas approché. Pour le travail long et ambigu, le haut de gamme chez Anthropic et Google, parce que tous deux le recommandent pour ce travail et que les points supplémentaires se gagnent sur les tâches difficiles ; chez OpenAI, le conseil de Codex est de rester sur Sol et de monter l’effort. Chez Anthropic, si Opus ne suffit pas même en xhigh ou en max, l’étape suivante est Fable 5.1. L’entrée de gamme va dans les sous-agents, parce qu’elle est en retard pour écrire du code mais proche pour lire du code et répondre à des questions dessus.

Pour votre propre travail, le chemin le plus fiable est une mesure. Les conseils des éditeurs se ressemblent : Anthropic recommande de comparer les modèles sur votre propre travail, au coût par tâche résolue et avec vos tâches les plus difficiles, et OpenAI d’essayer les mêmes entrées et de garder le réglage le plus léger qui atteint votre niveau de qualité. En pratique, prenez une poignée de tâches dans votre travail, faites tourner chaque modèle plusieurs fois dans son propre outil, et notez le coût par tâche résolue et la durée. Si vous avez des tests, lancez d’abord un réglage bon marché et ne refaites que les échecs à un réglage plus élevé ; nous avons expliqué pourquoi c’est économique dans l’article sur l’effort.