Le meilleur LLM pour coder en 2026 : 9 modèles classés

En février 2025, Claude 3.7 Sonnet affichait 62,3 % sur SWE-bench Verified, ou 70,3 % avec un échafaudage personnalisé, tandis que le meilleur modèle open weights du moment, DeepSeek-R1, annonçait 49,2 % dans son article.

Il y avait alors un écart de 13 à 21 points, selon votre générosité en matière d’échafaudage.

En septembre 2026, le comité indépendant Vals AI pour SWE-bench Verified crédite Claude Opus 5 de 97,0 % et l’open-weight DeepSeek V4 Pro 0813 de 96,4 %, puis Vals a archivé le benchmark car il était saturé.

La frontière s’est déplacée vers des évaluations agentiques plus difficiles comme SWE-bench Pro et Terminal-Bench 4.0, les open weights ont rattrapé les anciens tests, et la question « meilleur LLM pour coder » est devenue « meilleur pour quoi, sur quel matériel, et à quel prix ».

Je réponds à cette question pour les 9 modèles que j’utiliserais réellement aujourd’hui, et la version courte est que Claude Opus 5.5 est celui par lequel la plupart des équipes devraient commencer.

Une précision avant le classement : cet article concerne les modèles eux-mêmes, pas les outils qui les enveloppent. Si vous cherchez la comparaison Cursor, Copilot et Windsurf, notre tour d’horizon des meilleurs assistants de code IA en 2026 la couvre.

En bref : les meilleurs LLM de code en septembre 2026

Claude Opus 5.5 est désormais à la fois le modèle de code le plus performant sur la plupart des benchmarks et celui que la majorité des développeurs devrait choisir par défaut, Claude Fable 5.1 est celui à mobiliser pour les travaux à très long horizon, et Qwen3.8‑27B est le modèle open weights à exécuter sur un seul GPU. Voici les meilleurs choix par usage :

• Meilleur choix global pour le code agentique : Claude Opus 5.5 (Anthropic), 89,9 % sur SWE-bench Pro et 66,4 % sur Terminal-Bench 4.0, à 4 $ en entrée et 20 $ en sortie par million de tokens.
• Meilleur pour les travaux à très long horizon : Claude Fable 5.1 (Anthropic), 81,2 % sur SWE-bench Pro et meilleur score Terminal-Bench 2.1 sur Artificial Analysis (91,4 %), à 10 $ en entrée et 50 $ en sortie par million de tokens.
• Meilleur modèle OpenAI pour coder : GPT‑6 Astra (OpenAI), premier sur le classement agent Terminal-Bench 4.0 de tbench.ai à 58,2 %, et à égalité avec Opus 5.5 à 59,6 % sur l’exécution d’Artificial Analysis.
• Meilleure valeur chez un laboratoire de pointe : Gemini 3.8 Flash (Google), 89,4 % sur Terminal-Bench 2.1 pour 0,75 $ en entrée et 3,75 $ en sortie par million de tokens jusqu’au 31 décembre 2026.
• Meilleurs open weights via API : DeepSeek V4.1 Flash, licence MIT, 90,6 % sur Terminal-Bench 2.1, 0,60 $ par million de tokens en sortie hors heures de pointe.
• Meilleurs open weights impossibles à faire tourner chez soi : Kimi K3 (Moonshot AI), 2,8 billions de paramètres, 88,3 % sur Terminal-Bench 2.1.
• Meilleur modèle local sur un GPU de 24 Go : Qwen3.8‑27B (Alibaba), Apache 2.0, 73,0 % sur Terminal-Bench 2.1, 16,5 Go en UD‑Q4_K_M.
• Meilleur modèle local pour une station 128 Go : Laguna S 2.1 (Poolside), 118 B de paramètres avec seulement 8 B actifs, contexte 1 M.
• Meilleur modèle local rapide pour du matériel ancien : Qwen3‑Coder‑Next, 80 B au total mais 3 B actifs, 70,6 % sur SWE-bench Verified.

Tous les scores ci‑dessus sont publiés par les éditeurs sauf mention contraire. La suite de l’article explique comment j’en suis arrivé à ces choix et où chacun atteint ses limites.

Pourquoi cette liste parle des modèles et non des assistants de code ?

Un LLM de code est le modèle qui lit votre invite et génère des tokens, tandis qu’un assistant de code est le harnais qui lui fournit des fichiers, exécute ses commandes et vous affiche les diffs.

Claude Code, Codex, Cursor, GitHub Copilot et Windsurf sont des harnais. Claude Opus 5.5, GPT‑6 Astra et Qwen3.8‑27B sont des modèles, et le harnais influe sur le score bien plus que la plupart des gens ne l’imaginent.

Le billet de lancement de Claude Opus 4.8 d’Anthropic le montre très concrètement en note de bas de page.

Il publie le score Terminal-Bench 2.1 de chaque modèle sur le harnais public Terminus‑2, puis précise que le score de GPT‑5.5 grimpe à 83,4 % dans le CLI Codex d’OpenAI. Même poids, plomberie différente, résultat différent.

C’est pourquoi les classements ci‑dessous indiquent le harnais utilisé quand je l’ai trouvé. Si vous découvrez le fonctionnement interne de ces modèles, notre guide qu’est‑ce qu’un LLM se lit en 15 minutes et facilitera la suite.

Quels benchmarks comptent vraiment pour les LLM de code ?

En 2026, les benchmarks qui comptent pour les LLM de code sont SWE-bench Pro, Terminal-Bench (versions 2.1 et 4.0) et, pour les open weights qui le rapportent encore, LiveCodeBench v6. SWE-bench Verified a fait référence pendant 2 ans et est désormais trop saturé pour départager le haut du panier.

Avant de classer quoi que ce soit, voici ce que signifie chaque chiffre dans les fiches modèles.

SWE-bench Verified est saturé

SWE-bench Verified est un ensemble de 500 issues GitHub validées par des humains provenant de dépôts Python populaires ; le modèle reçoit le dépôt et le texte de l’issue et doit produire un patch qui passe des tests unitaires cachés.

OpenAI a introduit la sous‑collection Verified en 2024 car le SWE-bench original contenait des tâches mal spécifiées ou des tests cassés. Il reste la métrique la plus citée, ce qui est précisément le problème.

Le classement Vals AI, qui fait tourner chaque modèle via le même agent minimal limité à bash, place Claude Opus 5 à 97,0 %, DeepSeek V4 Pro 0813 à 96,4 % et GPT‑5.6 Sol à 96,2 % dans sa mise à jour du 1er septembre 2026, puis marque le benchmark comme archivé.

Quand 3 modèles de 3 laboratoires se tiennent à moins d’un point et à 4 points du plafond, la métrique ne discrimine plus. Je la cite encore pour les modèles plus anciens et plus petits car c’est le chiffre de leurs fiches, mais je ne classe plus dessus.

SWE-bench Pro est le remplaçant plus difficile

SWE-bench Pro, maintenu par Scale AI, contient 1 865 tâches sur 41 dépôts professionnels, avec un split public de 731 tâches et des jeux privés tenus à part. Le 22 septembre 2026, Scale a publié SWE-Bench Pro V2, qui réduit le set public à 642 tâches après en avoir retiré 89 jugées invalides ; vérifiez donc la version du score.

La correction moyenne touche 107,4 lignes à travers 4,1 fichiers, et les dépôts couvrent plusieurs langages au‑delà de Python. Lorsque l’article SWE-bench Pro est sorti en septembre 2025, les meilleurs modèles tournaient autour de 23 %.

Un an plus tard, la fiche système de Fable 5.1 annonce 81,2 % pour Fable 5.1 et 79,2 % pour Opus 5, et le tableau de lancement de GPT‑5.6 indique 64,6 % pour GPT‑5.6 Sol. Trois semaines après la fiche Fable, la fiche système d’Opus 5.5 a poussé le meilleur score à 89,9 %.

Ce sont des exécutions éditeur, moyennées sur 5 essais à effort maximal chez Anthropic. Le classement public de Scale accuse plusieurs mois de retard sur les chiffres éditeurs, je traite donc le chiffre éditeur comme le plafond et le leaderboard comme le plancher.

Terminal-Bench 2.1 et 4.0

Terminal-Bench donne à un modèle un shell vivant dans un conteneur et une tâche comme « entraîner ce modèle », « corriger ce build » ou « récupérer cette archive corrompue », puis évalue les artefacts produits.

La version 2.1 réunit 89 tâches sélectionnées couvrant génie logiciel, administration système, data processing et sécurité, et Artificial Analysis la note en pass@1 moyenné sur 3 exécutions avec le harnais Terminus 2. C’est le chiffre que je pèse le plus pour ceux qui construisent ou utilisent des agents de code.

Terminal-Bench 4.0, hébergé par Stanford, Harbor et l’Institut Laude sur tbench.ai, est le nouveau jeu de pointe.

La fiche d’Opus 5.5 chez Anthropic le décrit comme 66 tâches orientées biologie computationnelle, simulation physique, CAO, preuves formelles et performance GPU, avec des timeouts plus longs de sorte que le harnais influe moins.

Sur le classement agent de tbench.ai, GPT‑6 Astra mène encore à 58,2 % avec le harnais Codex à effort max, Claude Fable 5.1 suit à 57,9 %, mais Claude Opus 5.5 n’a pas encore d’entrée agent là‑bas. Sur des exécutions au niveau modèle, Artificial Analysis a Opus 5.5 et Astra à égalité à 59,6 %, et Vals AI place Opus 5.5 premier à 61,6 %, tout en notant que ce chiffre tombe à 53,5 % si l’on compte comme échecs les tâches que ses garde‑fous ont déléguées à un modèle de repli. C’est là que la frontière se détache du peloton.

LiveCodeBench v6 traque la mémorisation

LiveCodeBench, introduit dans l’article de 2024 de Jain et collègues, collecte en continu des problèmes depuis LeetCode, AtCoder et Codeforces et horodate chacun pour évaluer un modèle uniquement sur les problèmes postérieurs à sa coupure d’entraînement.

La version 6 est la fenêtre actuelle sur le classement public. Elle mesure le raisonnement algorithmique plutôt que l’ingénierie à l’échelle dépôt, ce qui la maintient utile pour les exercices d’entretien et de structures de données.

Les labs de pointe ont surtout cessé de la publier en 2026, donc les chiffres que j’ai viennent des open weights : l’aperçu DeepSeek V4 Pro d’avril à 93,5 %, Qwen3.8‑27B à 90,3 % et Kimi K2.6 à 89,6 %. Gemini 3.1 Pro publie une métrique voisine, un Elo LiveCodeBench Pro de 2 887.

Ma lecture d’un tableau de benchmarks éditeur

Un tableau éditeur est un meilleur cas : leur harnais, leur niveau d’effort, leur nombre d’essais. Je cherche une réplication indépendante sur Artificial Analysis, Vals AI ou le classement tbench.ai avant de croire à un écart inférieur à 3 points.

Notre introduction aux benchmarks LLM et à la comparaison des modèles passe en revue les principaux classements, et notre article sur ce que mesure MMLU rappelle qu’un benchmark de connaissances ne dit presque rien de la capacité d’un modèle à corriger un test instable.

Pour construire votre propre harnais d’évaluation, notre guide sur les métriques et méthodologies d’évaluation des LLM est celui que je recommande d’abord aux juniors.

Avec ces benchmarks en tête, voici comment les 9 modèles s’en sortent, en commençant par le cloud de pointe.

Quels sont les meilleurs modèles cloud de pointe pour coder ?

Les meilleurs modèles cloud de pointe pour coder en septembre 2026 sont Claude Opus 5.5, Claude Fable 5.1, GPT‑6 Astra et Gemini 3.8 Flash, et tous les 4 offrent une fenêtre de contexte d’environ 1 million de tokens.

Les différences tiennent au prix, aux réglages d’effort et aux benchmarks que chaque lab a optimisés.

Je les liste dans l’ordre où je les recommanderais à une équipe qui peut se permettre n’importe lequel.

1. Claude Opus 5.5 (Anthropic)

Claude Opus 5.5 est le nouveau fleuron Opus d’Anthropic, sorti le 22 septembre 2026, et c’est désormais le modèle de code que je recommande à presque tout le monde. Je ne m’attendais pas à écrire cela 2 mois après Opus 5. Le billet de lancement d’Anthropic indique qu’il atteint le niveau de Fable 5.1 sur la plupart des travaux tout en coûtant 40 % de moins qu’Opus 5, et la page de présentation des modèles conseille désormais aux développeurs de démarrer avec Opus 5.5 et de passer à Fable 5.1 pour les travaux à long horizon ou lorsque les évaluations sous Opus 5.5 sont insuffisantes.

La fiche système d’Opus 5.5 annonce 89,9 % sur SWE-bench Pro, 74,2 % sur DeepSWE v1.1 et 66,4 % sur Terminal-Bench 4.0 à effort xhigh, devant Fable 5.1 sur toutes les lignes « code » publiées par Anthropic. Les chiffres indépendants sont plus serrés : Artificial Analysis l’a mesuré à égalité avec GPT‑6 Astra à 59,6 % sur Terminal-Bench 4.0, et Vals AI le place premier à 61,6 % sur Terminal-Bench 4.0 et 87,6 % sur Terminal-Bench 2.1. Les deux chiffres Vals incluent les bascules de garde‑fous ; les compter en échecs les fait tomber à 53,5 % et 79,8 %.

Atouts :

• 4 $ par million de tokens en entrée et 20 $ en sortie, 20 % sous Opus 5, avec les lectures de cache en baisse de 60 % à 0,20 $ par million
• Contexte 1 M, sortie 128 K, « adaptive thinking » non désactivable, et effort par défaut medium plutôt que high
• 57,8 % sur CursorBench 4.0 à effort max, meilleur score du classement de Cursor ; en medium, 52,5 %, encore au‑dessus de Fable 5.1 en max
• Disponible sur l’API Claude sous claude-opus-5-5, ainsi que sur Amazon Bedrock, Google Cloud et Microsoft Foundry

Idéal pour : le codage quotidien, les migrations à l’échelle du codebase et la revue de code. Il remplace purement et simplement Opus 5 à un prix inférieur, et Claude Code l’utilise désormais par défaut pour l’édition Opus. Notre guide Claude Opus 5.5 couvre le lancement, et notre comparatif GPT‑6 Sol vs Claude Opus 5.5 inclut un test pratique.

Compromis : l’économie de 40 % s’applique à l’effort par défaut. À effort max, Artificial Analysis a constaté une consommation de tokens bien supérieure à celle d’Opus 5, si bien que son coût par tâche Intelligence Index (5,98 $) est quasi au niveau d’Opus 5 (5,86 $). Il embarque aussi des garde‑fous à la Fable qui routent la plupart des tâches cybersécurité vers Opus 4.8, et les migrations de code demandent de l’attention, car les requêtes avec pensée désactivée ou usage d’outils forcé renvoient désormais des erreurs.

2. Claude Fable 5.1 (Anthropic)

Claude Fable 5.1 est la version publique du modèle de classe Mythos d’Anthropic, sortie le 1er septembre 2026, et c’est le modèle vers lequel j’escalade quand Opus 5.5 arrive au bout. La page de lancement d’Anthropic précise que Fable 5.1 et Claude Mythos 5.1 sont le même modèle avec des garde‑fous différents.

Les chiffres de la fiche système Fable 5.1 sont 81,2 % sur SWE-bench Pro et 55,8 % sur Terminal-Bench 4.0. Artificial Analysis a mesuré indépendamment 91,4 % sur Terminal-Bench 2.1 à effort max, toujours le meilleur score de ce tableau.

Atouts :

• Fenêtre de contexte 1 M et 128 K tokens de sortie
• « Adaptive thinking » toujours activé
• Les lectures de cache d’invite baissent de 75 % à 0,25 $ par million de tokens avec la 5.1, ce qui, selon Anthropic, réduit jusqu’à 45 % les charges agentiques
• Planification multi‑fichiers robuste et réflexion plus large avec un meilleur usage des outils

Idéal pour : les pipelines agentiques en production, les refactors sur plusieurs jours, et toute tâche où une mauvaise réponse coûte plus cher que les tokens, une fois vos évaluations montrant qu’Opus 5.5 est court sur ce point. Notre guide Claude Fable 5.1 couvre cette sortie, et notre aperçu Claude Fable 5 couvre la version de juin.

Compromis : 10 $ par million de tokens en entrée et 50 $ en sortie, soit 2,5 fois le tarif d’Opus 5.5, et dans le tableau d’Anthropic, Fable 5.1 est désormais derrière Opus 5.5 sur SWE-bench Pro, Terminal-Bench 4.0 et CursorBench 4.0. Anthropic affirme que l’écart réel est plus étroit que ces scores ne le laissent penser, mais la charge de la preuve s’est inversée. Sur l’ancien CursorBench 3.2.0, Fable 5.1 en effort medium a obtenu 68,0 % pour 3,53 $ par tâche.

3. GPT‑6 Astra (OpenAI)

GPT‑6 Astra est le modèle de pointe d’OpenAI, sorti le 3 septembre 2026, et il demeure premier sur le classement agent Terminal-Bench 4.0 de tbench.ai à 58,2 % avec le harnais Codex à effort max, bien qu’Opus 5.5 n’y ait pas encore d’entrée agent.

La page modèle affiche une fenêtre de contexte de 1 050 000 tokens, 128 000 tokens de sortie, une coupure de connaissances au 30 avril 2026, et des niveaux d’effort de none à max. Les prix sont 10 $ par million de tokens en entrée, 1 $ pour l’entrée mise en cache, et 50 $ par million en sortie.

Les supports de lancement d’OpenAI s’appuient sur leurs propres évaluations et la fiche système plutôt que sur les benchmarks inter‑labs. Leurs évaluations sont solides, mais je n’en ferais pas un vainqueur net face à Opus 5.5 ou Fable 5.1. Nous couvrons les chiffres de lancement dans notre aperçu de GPT‑6 Astra.

Atouts :

• La Responses API expose hosted_shell, apply_patch, computer_use et tool_search, l’ensemble d’outils utilisé par Codex lui‑même.
• Entrée mise en cache à 1 $ par million de tokens, un dixième du prix de base, utile pour les boucles agents qui relisent le même dépôt.
• Astra est le premier modèle OpenAI à atteindre le palier cybersécurité le plus élevé de son Preparedness Framework, donc certaines requêtes liées à la sécurité sont filtrées.

Idéal pour : les équipes déjà sur Codex, GitHub Copilot ou l’écosystème Microsoft, les tâches à forte teneur scientifique et d’ingénierie, et ceux qui ont besoin d’un meilleur support d’outils tiers. Si vous voulez l’essentiel des capacités pour moins cher, GPT‑6 Sol, sorti le 22 septembre à 2 $ en entrée et 10 $ en sortie par million, succède à GPT‑5.6 Sol, et sans GPT‑6 Terra, il occupe désormais l’ancien créneau de prix de Terra. Sur les graphiques d’OpenAI il atteint 68,8 % sur DeepSWE 1.1 et 49,3 % sur FrontierCode, bien que GPT‑5.6 Sol en effort max reste plus haut sur DeepSWE.

Compromis : des tarifs à la Fable, et Opus 5.5 égale désormais Astra sur Terminal-Bench 4.0 pour environ 40 % du coût par tâche selon Anthropic, avec Artificial Analysis donnant les deux à égalité. Les atouts les plus clairs d’Astra sont les travaux très scientifiques : 64,6 % sur Terminal-Bench‑Science et 65,5 % sur FrontierSWE v2, tous deux devant Opus 5.5.

4. Gemini 3.8 Flash (Google)

Gemini 3.8 Flash est le modèle « cheval de bataille » de Google, sorti le 2 septembre 2026, et l’un des moyens les moins chers d’obtenir un score agentique de niveau frontier (GPT‑6 Luna coûte moins par token, mais affiche des scores agentiques inférieurs). Le rapport d’évaluation de Google indique 89,4 % sur Terminal-Bench 2.1 et 73,7 % sur DeepSWE v1.1, une suite longue de 113 tâches où Fable 5.1 a obtenu 67,4 %. Le même tableau place Opus 5 légèrement devant à 74,0 %, Anthropic annonce 74,2 % pour Opus 5.5, et le guide développeur Google ajoute 61,6 % sur SWE-bench Pro.

Les tarifs sur la page de prix de l’API Gemini sont de 0,75 $ par million de tokens en entrée et 3,75 $ par million en sortie jusqu’au 31 décembre 2026, puis 1,50 $ et 7,50 $ à partir du 1er janvier 2027. Même au prix 2027, cela reste un peu plus d’un tiers du tarif de sortie d’Opus 5.5. La fenêtre de contexte est de 1 M en entrée avec 64 K en sortie.

Atouts :

• Entrée multimodale native, vous pouvez donc lui fournir un schéma d’architecture ou une capture d’écran d’une UI défaillante à côté du code.
• Google le positionne pour les travaux agentiques à fort volume et le tarifie en conséquence.
• Une variante Cyber existe pour les vulnérabilités, avec accès distinct, que nous couvrons dans notre présentation de Gemini 3.8 Flash et Flash Cyber.

Idéal pour : les boucles agents à grand volume, les équipes sensibles au coût et les environnements Vertex AI. Gemini 3.1 Pro, sorti le 19 février 2026, reste le modèle de la gamme Pro de Google avec 54,2 % sur SWE-bench Pro à 2 $ en entrée et 12 $ en sortie par million, mais pour le code spécifiquement, je choisirais aujourd’hui 3.8 Flash plutôt que 3.1 Pro.

Compromis : 19,1 % sur Terminal-Bench 4.0. Flash est solide sur les tâches terminal bien cadrées et faible sur les tâches de science de pointe, gardez donc un modèle plus fort à portée pour les tickets les plus durs.

Voilà pour les modèles cloud. La suite de la liste couvre les modèles téléchargeables.

Quels sont les meilleurs LLM open weights pour coder en 2026 ?

Les meilleurs LLM open weights pour coder en 2026 se scindent en 2 groupes : des modèles taille datacenter comme DeepSeek V4.1 Flash et Kimi K3, qui égalent les scores de pointe mais exigent un matériel serveur sérieux, et des modèles sous 120 B comme Qwen3.8‑27B et Laguna S 2.1 que vous pouvez exécuter sur votre propre matériel.

« Open weight » signifie ici que les poids sont téléchargeables. Les licences vont de MIT et Apache 2.0 à des termes sur mesure.

5. DeepSeek V4.1 Flash (DeepSeek)

DeepSeek V4.1 Flash est la sortie du 10 septembre 2026 de DeepSeek, et malgré son nom « Flash », c’est désormais le modèle DeepSeek que je privilégie. DeepSeek affirme qu’il surpasse son fleuron V4 Pro 0813 en performance, coût, vitesse et temps d’achèvement des tâches. L’indice indépendant de Vals AI va dans le même sens, le classant meilleur modèle open weights à 57,9 %, contre 52,4 % pour V4 Pro 0813 mesuré par Vals en août.

C’est un modèle Mixture‑of‑Experts de 552 B paramètres avec environ 8 B actifs par token en entrée et 16 B en sortie, contexte 1 M, entrée image native et poids sous licence MIT. DeepSeek annonce 90,6 % sur Terminal-Bench 2.1 et 74,2 % sur DeepSWE v1.1, les meilleurs scores open weights rapportés par un éditeur sur les deux. L’exécution Terminal-Bench 2.1 de Vals AI est moins généreuse à 74,5 %, deuxième parmi les open weights.

Nous détaillons la sortie dans notre aperçu de DeepSeek V4.1 Flash.

Atouts :

• Tarifs API sur la page de prix DeepSeek : 0,15 $ par million de tokens en entrée et 0,60 $ en sortie hors heures de pointe, doublés à 0,30 $ et 1,20 $ en semaine aux heures de pointe (01:00–04:00 et 06:00–10:00 UTC). Les hits de cache coûtent 0,003 $ par million hors pointe.
• Servi comme deepseek-flash via une API compatible OpenAI, donc le script ask_coding_model.py plus bas fonctionne avec un simple changement d’URL de base.
• Un KV cache environ quatre fois plus petit que celui de V4 Flash, ce qui explique ce prix très bas en long contexte.

Idéal pour : du code agentique proche du frontier pour quelques centimes, et des jobs de code par lots que vous pouvez planifier hors pointe.

Compromis : 31,2 % sur Terminal-Bench 4.0 selon le propre rapport de DeepSeek, donc les tâches agentiques les plus longues et difficiles restent l’apanage des labs de pointe. Le checkpoint pèse aussi environ 510 Go, donc « open weights » signifie ici serveur multi‑GPU. Si vous êtes sur V4 Pro 0813, DeepSeek a annoncé router ce modèle vers V4.1 Flash le 14 septembre, puis a fait marche arrière, et V4 Pro est toujours servi à 0,66 $/1,98 $ hors pointe jusqu’à nouvel ordre.

6. Kimi K3 (Moonshot AI)

Kimi K3 est le fleuron open weights de Moonshot AI à 2,8 billions de paramètres, sorti en juillet 2026, et il affiche 88,3 % sur Terminal-Bench 2.1, deuxième modèle open derrière le 90,6 % de DeepSeek V4.1 Flash annoncé par l’éditeur.

La fiche Hugging Face indique 104 B de paramètres actifs sur 896 experts (16 routés plus 2 partagés par token), un contexte de 1 048 576 tokens et des poids MXFP4. Vals AI a mesuré 93,4 % sur SWE-bench Verified.

Atouts :

• Contexte 1 M avec vision native.
• Distribué sous licence Kimi K3, une licence personnalisée plutôt que MIT ou Apache ; lisez‑la avant un usage commercial.
• Stacks d’inférence recommandées : vLLM, SGLang et TokenSpeed, et Moonshot a calibré certaines tâches GPU pour des H20.

Idéal pour : quiconque veut le plus fort agent de code open disponible.

Compromis : une capacité proche du frontier n’existe qu’à l’échelle datacenter. L’écart de 3 points face à Fable 5.1 sur Terminal-Bench 2.1 paraît faible, mais ce n’est pas comparable : Moonshot a mesuré 88,3 % dans son propre harnais Kimi Code, tandis que les 91,4 % de Fable viennent des exécutions Terminus 2 d’Artificial Analysis. En pratique, vous le louez chez un hébergeur ou vous faites tourner votre propre cluster, avec en sus une licence personnalisée à valider avec le juridique.

7. Qwen3.8‑27B (Alibaba)

Qwen3.8‑27B est un modèle dense de 27 milliards de paramètres sorti en août 2026 sous Apache 2.0, et c’est le meilleur LLM de code que vous pouvez exécuter sur un seul GPU de 24 Go.

La fiche modèle annonce 61,7 % sur SWE-bench Pro, 73,0 % sur Terminal-Bench 2.1, 90,3 % sur LiveCodeBench v6 et 42,2 % sur DeepSWE 1.1, avec un contexte natif de 262 144 tokens extensible à 1 M avec YaRN. Ces scores SWE-bench Pro et Terminal-Bench dépassent Laguna S 2.1, un modèle 4 fois plus gros, et battent Gemini 3.1 Pro sur SWE-bench Pro. Certes, Qwen a exécuté SWE-bench Pro sur son propre set corrigé, donc traitez ces comparaisons inter‑labs comme indicatives.

Atouts :

• Le GGUF UD‑Q4_K_M de la communauté Unsloth tient dans un fichier unique de 16,5 Go, ce qui laisse un contexte de 32 K sur une carte de 24 Go. UD‑Q4_K_XL fait 17,6 Go.
• Architecture dense, donc plus lent par token qu’un MoE 3 B actif mais nettement plus régulier sur les modifications multi‑fichiers.
• Apache 2.0, aucune restriction d’usage en produit commercial.

Idéal pour : les développeurs qui ne peuvent pas envoyer de code vers une API externe, les indépendants avec un seul GPU de classe RTX, et quiconque veut comparer local vs Claude sur son propre dépôt avant de payer le cloud.

Compromis : 73,0 % vs 91,4 % sur Terminal-Bench 2.1 reste un écart de 18 points, qui se traduit par plus de relances sur les longues tâches agentiques.

8. Laguna S 2.1 (Poolside)

Laguna S 2.1 est le modèle de code Mixture‑of‑Experts de 118 B paramètres de Poolside avec 8 B actifs, sorti le 21 juillet 2026, et c’est le choix open weights pour un Mac Studio, un DGX Spark ou une station multi‑GPU.

Le billet de lancement de Poolside rapporte 59,4 % sur le set public SWE-bench Pro, 70,2 % sur Terminal-Bench 2.1 avec thinking au max (60,4 % sans thinking), 78,5 % sur SWE-bench Multilingual et 40,4 % sur DeepSWE.

Le modèle a été entraîné sur 409 000 environnements, dont 83 000 tâches terminal et 168 000 workflows d’ingénierie logicielle, sur 4 096 H200 en moins de 9 semaines.

Atouts :

• Fenêtre de contexte 1 M, inhabituel à cette taille.
• Licence OpenMDW‑1.1, permissive mais à faire relire par votre juridique.
• Le mode « thinking » est activé par défaut et vaut environ 10 points sur Terminal-Bench 2.1 ; la longueur moyenne des complétions allait d’environ 23 K à 249 K tokens par tâche dans les exécutions de Poolside, prévoyez le budget en conséquence.

Idéal pour : les équipes qui veulent un agent local façon Claude Code sur une machine à 96–128 Go de mémoire unifiée, et des dépôts assez volumineux pour nécessiter le contexte 1 M en local.

Compromis : 118 B paramètres en 4 bits, c’est environ 60 à 70 Go de poids avant d’allouer un KV cache, donc un GPU de 24 Go est exclu. Sur les scores bruts Qwen3.8‑27B le devance, mais les 8 B actifs de Laguna le rendent bien plus rapide une fois les poids chargés, ce qui est l’objectif d’un agent nocturne.

9. Qwen3‑Coder‑Next (Alibaba)

Qwen3‑Coder‑Next est un modèle Mixture‑of‑Experts de 80 B paramètres qui n’active que 3 B par token, sorti le 3 février 2026 sous Apache 2.0, et c’est le codeur local le plus rapide et capable pour du matériel qui ne peut pas tenir un dense 27 B à vitesse.

La fiche modèle indique 70,6 % sur SWE-bench Verified, 44,3 % sur SWE-bench Pro et 36,2 % sur Terminal-Bench 2.0, avec 512 experts (10 actifs plus 1 partagé) et un contexte de 262 144 tokens. Il fonctionne uniquement en mode sans « thinking ».

Atouts :

• Le GGUF Q4_K_M officiel pèse environ 48 Go, adapté à un Mac 64 Go ou à une configuration CPU‑offload plutôt qu’à un seul GPU grand public.
• Attention hybride (3 couches Gated DeltaNet par couche d’attention standard) qui maintient une faible mémoire en long contexte.
• Pris en charge par vLLM, SGLang, Ollama, LM Studio, MLX‑LM, llama.cpp et KTransformers, selon la fiche.

Idéal pour : des tâches longues du soir où les tokens par seconde comptent plus que la précision de pointe, et des laptops avec 64 Go de mémoire unifiée.

Compromis : 44,3 % sur SWE-bench Pro, soit 17 points derrière Qwen3.8‑27B ; pour un bug difficile unique, je privilégierais le modèle dense.

Autres open weights à considérer

Quatre modèles supplémentaires ont presque intégré la liste, et 2 d’entre eux conviendront mieux que mes choix à certaines équipes :

• DeepSeek V4 Pro 0813 (DeepSeek) : 1,6 T au total, 49 B actifs, contexte 1 M, licence MIT, 96,4 % sur le SWE-bench Verified archivé de Vals AI. Toujours servi à 0,66 $ en entrée et 1,98 $ en sortie par million hors pointe, mais Vals l’a mesuré à 54,7 % sur Terminal-Bench 2.1 contre 87,9 % rapportés par DeepSeek, et DeepSeek oriente désormais vers V4.1 Flash. Notre décryptage de DeepSeek V4 couvre l’architecture.
• Kimi K2.6 (Moonshot) : 1 T au total, 32 B actifs, contexte 256 K, licence MIT modifiée, 80,2 % SWE-bench Verified, 58,6 % SWE-bench Pro et 89,6 % LiveCodeBench v6. La licence la plus propre parmi les modèles au billion, après le MIT pur de DeepSeek V4 Pro.
• MiniMax M3 : 428 B au total, 23 B actifs, contexte 1 M, entrée image et vidéo native, 80,5 % SWE-bench Verified et 59 % SWE-bench Pro. Le choix open si vos tâches mêlent code et captures.
• Qwen3.8‑Flash‑Next : 125 B au total avec 6 B actifs, 62,5 % SWE-bench Pro et 58,7 % DeepSWE, sous la licence plus restrictive qwen‑community‑1.0. Plus fort que Qwen3.8‑27B sur DeepSWE, mais la licence l’a tenu hors de mon top 9.

Si l’un de ces open weights convient à votre matériel, la section suivante montre comment le faire tourner.

Comment exécuter un modèle de code open weight en local ?

Exécuter un modèle de code open weight en local tient en 3 étapes : télécharger un checkpoint quantifié, le servir derrière un endpoint compatible OpenAI, et pointer votre client ou assistant de code vers cet endpoint. Je prends Qwen3.8‑27B en exemple car c’est le plus simple des 9 à faire tenir sur du matériel grand public.

Premièrement, le téléchargement. La bibliothèque huggingface_hub gère les transferts reprenables et le cache, utile avec ces gros fichiers :

"""Téléchargez un modèle de code quantifié depuis Hugging Face.
 
Qwen3.8-27B en UD-Q4_K_M tient dans un unique fichier de 16,5 Go, ce qui
laisse un contexte de 32K sur un GPU de 24 Go. Remplacez FILENAME par la
build UD-Q4_K_XL si vous avez 1 Go de plus à y consacrer.
"""
 
from huggingface_hub import hf_hub_download
 
REPO_ID = "unsloth/Qwen3.8-27B-GGUF"
FILENAME = "Qwen3.8-27B-UD-Q4_K_M.gguf"
 
 
def fetch(repo_id: str = REPO_ID, filename: str = FILENAME) -> str:
    """Télécharger un fichier du Hub et renvoyer son chemin local."""
    path = hf_hub_download(repo_id=repo_id, filename=filename)
    print(f"Saved to {path}")
    return path
 
 
if __name__ == "__main__":
    fetch()

Enregistrez sous download_gguf.py et exécutez uv run --with huggingface_hub python download_gguf.py. Sous Windows vous verrez un avertissement sur les symlinks si le mode Développeur n’est pas activé.

Deuxièmement, le service.

Parmi llama.cpp (llama-server), LM Studio ou Ollama, tous exposent un endpoint /v1 compatible OpenAI. Avec llama.cpp la commande tient en une ligne, et 2 flags font l’essentiel : -ngl 99 déporte toutes les couches sur le GPU et -c 32768 fixe un contexte 32K.

llama-server -m Qwen3.8-27B-UD-Q4_K_M.gguf -c 32768 -ngl 99 --port 8080

Troisièmement, le client. Je garde un script par modèle que j’évalue, local ou hébergé, et je change de cible avec 3 variables d’environnement. Le même fichier parle au serveur local ci‑dessus, à l’API DeepSeek ou à celle d’OpenAI :

"""Envoyer une invite de code à n'importe quel endpoint compatible OpenAI.
 
Le même script parle à un serveur local llama.cpp ou vLLM, à l'API de
DeepSeek, ou à OpenAI. Seules trois variables d'environnement changent :
 
    LLM_BASE_URL   ex. http://localhost:8080/v1  ou  https://api.deepseek.com
    LLM_MODEL      ex. qwen3.8-27b  ou  deepseek-flash
    LLM_API_KEY    n'importe quelle valeur non vide pour un serveur local
"""
 
import os
 
from openai import OpenAI
 
PROMPT = (
    "Write a Python function top_n(df, col, n) that returns the n largest "
    "rows of a pandas DataFrame by column col, with a docstring and a "
    "ValueError if col is missing."
)
 
 
def ask(prompt: str = PROMPT) -> str:
    """Renvoyer la réponse du modèle pour une requête de code mono-tour."""
    client = OpenAI(
        base_url=os.environ["LLM_BASE_URL"],
        api_key=os.environ.get("LLM_API_KEY", "local"),
    )
    response = client.chat.completions.create(
        model=os.environ["LLM_MODEL"],
        messages=[{"role": "user", "content": prompt}],
        temperature=0.2,  # maintenir une génération de code quasi déterministe
    )
    return response.choices[0].message.content
 
 
if __name__ == "__main__":
    print(ask())

Enregistrez sous ask_coding_model.py et lancez avec LLM_BASE_URL=http://localhost:8080/v1 LLM_MODEL=qwen3.8-27b uv run --with openai python ask_coding_model.py.

Si vous reliez ensuite plusieurs endpoints dans une application avec routage, relances et appels d’outils, notre cours sur le développement d’applications LLM avec LangChain couvre les abstractions qui évitent d’empiler les if.

Comment choisir le meilleur LLM pour coder ?

Choisir le meilleur LLM pour coder dépend de 4 contraintes : si votre code peut quitter votre machine, la mémoire dont vous disposez, le prix que vous paierez par million de tokens en sortie, et la quantité de contexte nécessaire à une tâche. Le tableau ci‑dessous met côte à côte les 9 modèles classés selon les chiffres en lesquels j’ai le plus confiance, et le guide de décision qui suit fait correspondre ces contraintes à un choix.

Le guide de décision

Voici comment je fais correspondre les 4 contraintes au classement :

• Pipelines de code agentiques où la justesse prime sur le coût : Claude Opus 5.5 à effort high ou xhigh, avec Fable 5.1 en renfort pour les tâches à long horizon où vos évaluations montrent qu’Opus 5.5 est juste.
• Codage assisté par IA au quotidien à prix raisonnable : Claude Opus 5.5 d’abord à son effort medium par défaut, GPT‑6 Sol en second si vous vivez dans Codex.
• Science de pointe, simulation ou kernels GPU : GPT‑6 Astra ou Claude Opus 5.5. Astra mène sur Terminal-Bench‑Science, Opus 5.5 sur Terminal-Bench 4.0.
• Codebase massif, prompts 1 M tokens, budget serré : Gemini 3.8 Flash pour le prix, Opus 5.5 quand les réponses de Flash se dégradent.
• Open weights via API : DeepSeek V4.1 Flash hors pointe.
• Local et privé sur un seul GPU 24 Go : Qwen3.8‑27B en UD‑Q4_K_M.
• Local et privé sur une machine 96 à 128 Go : Laguna S 2.1, ou Kimi K3 si « machine » signifie « cluster ».
• Local et rapide sur un laptop 64 Go : Qwen3‑Coder‑Next.

Si vous voulez un cadre plus général pour apparier un modèle à une application, incluant hébergement et licences, notre guide comment choisir le meilleur LLM pour votre application va au‑delà du code.

Et quel que soit le modèle choisi, les compétences qui en tirent de la valeur sont les mêmes : notre parcours de compétences AI for Software Engineering et notre cours AI‑assisted coding for developers enseignent les habitudes de prompt, de test et de revue qui transforment un 91 % de benchmark en pull request fusionnée.

Conclusion

Claude Opus 5.5 est le meilleur LLM de code en septembre 2026 et, fait rare, aussi celui à mettre sur la facture de votre équipe. Claude Fable 5.1 est la voie d’escalade pour les tâches les plus longues, et Qwen3.8‑27B est le modèle open weight qui transforme un GPU de 24 Go en assistant de code privé qui dépasse le frontier de l’an dernier sur SWE-bench Pro. Le reste dépend de vos contraintes, et le guide de décision ci‑dessus est ma façon de les trancher.

Le plus grand changement, c’est que le benchmark qui a défini cette catégorie pendant 2 ans, SWE-bench Verified, a cessé de compter la même année où les open weights l’ont rattrapé.

Ce n’est pas un hasard.

Quand Opus 5 et DeepSeek V4 Pro ne sont séparés que de 0,6 point sur un test saturé, et qu’un modèle à 20 $ par million bat désormais celui d’Anthropic à 50 $ sur SWE-bench Pro, la valeur s’est déplacée vers la conception du harnais, les budgets d’effort et l’évaluation sur votre propre dépôt — exactement ce qu’un tableau éditeur ne peut pas faire à votre place.

Faites donc ce travail. Prenez le script ask_coding_model.py, pointez‑le vers 2 ou 3 de ces modèles, exécutez‑le sur 20 tickets réels de votre backlog au niveau d’effort que vous paierez réellement, et laissez ce résultat primer sur tout ce que j’ai écrit ici. Si le « vibe coding » vous parle plus que les harnais d’évaluation, notre article sur ce qu’est le vibe coding et ses limites dresse un tableau honnête des compromis, et le même classement de modèles s’applique.