Mon agent IA a créé un outil de benchmarking pour mes agents IA

Publié
11 août 2026
Mis à jour
9 novembre 2026
Par
Jacob Lloyd — rédigé avec l'aide de l'IA, une fois le projet terminé
Temps de lecture
28 min de lecture

En clair : Notre agent de codage IA a écrit bench-llm, un unique fichier Python qui teste la vitesse d'un modèle local et sa capacité à effectuer des tâches simples. Il fonctionne toujours et est gratuit à télécharger. Il est devenu trop facile en l'espace de deux semaines, nous l'avons donc remplacé par CrucibleForge, un outil gratuit plus complet qui pose 276 questions et exécute le code écrit par le modèle pour le vérifier.

Le 2026-08-11, nous avons demandé à notre agent de codage un outil pour évaluer les modèles locaux de notre pile d'agents. Il nous a livré bench-llm : 1 660 lignes de Python qui mesurent la vitesse dans LM Studio, exécutent le code écrit par un modèle et vérifient si le modèle peut gérer une petite tâche d'agent. En deux semaines, tous les modèles qui nous intéressaient obtenaient 5/5, nous l'avons donc reconstruit sous le nom de CrucibleForge : 276 cas en octobre 2026, dont 166 difficiles, open source sur GitHub. Cette page couvre les deux. Utilisez bench-llm pour obtenir un premier chiffre sur un modèle en cinq minutes. Utilisez CrucibleForge quand vous devez classer des modèles qui réussissent tous les tests faciles.

tl;dr

  • bench-llm : un seul fichier Python, téléchargement gratuit. Il teste la Vitesse (temps jusqu'au premier token, tokens/seconde), la Capacité (5 tests : code, logique, JSON, instructions, synthèse) et l'Aptitude d'agent (3 vérifications sur une tâche syslog). Nécessite Python 3.8+, pip install openai requests et LM Studio.
  • Pourquoi il a été retiré : 5 tests de capacité et 3 vérifications d'agent cessent de distinguer les modèles une fois que les bons modèles les réussissent tous.
  • CrucibleForge 3.6 : 276 cas, dont 166 difficiles. Le code s'exécute dans un bac à sable et est noté sur le résultat. Il fonctionne avec tout point de terminaison compatible OpenAI, dispose d'une interface web et tourne désormais dans Docker et sous Windows. Licence MIT, github.com/LaserLloyd/CrucibleForge.
  • Ce que montre le tableau : Kimi K3.1 Pro a le meilleur score du tableau du 2026-11-08 avec 19,3 sur 20, bien que le test apparié du tableau lui-même déclare les 26 modèles à égalité ; MiniMax M3 obtient pour la première fois un score jugé (14,6, et 15,5 une fois ses nouvelles exécutions comptées) à environ 0,57 $ par exécution, et l'ensemble du tableau a coûté 68,21 $.

Journal des modifications : 2026-08-26, bench-llm retiré et résultats transférés aux suites successives. 2026-09-16, section CrucibleForge réécrite, classement reconstruit à partir des fichiers d'exécution sauvegardés, couverture redessinée. 2026-10-19, section CrucibleForge mise à jour pour la 3.6.0 (nouveautés) : installation actuelle, benchmark en une commande, Docker. 2026-11-02, tableau des modèles reconstruit à partir de l'exécution du 2026-11-02 (suite 4.0.0). 2026-11-09, tableau des cas difficiles reconstruit à partir de l'exécution du 2026-11-08 (suite 4.1.0) : 26 modèles jugés, coût d'exécution de nouveau affiché sur le tableau, MiniMax M3 noté pour la première fois.

Résultat final

Une seule commande exécutée sur un modèle affiche ceci (exemple d’exécution, tronqué) :

$ bench-llm gemma-4-31b-it

  bench-llm — Benchmarking: gemma-4-31b-it
  GGUF Size:     16.5 GB     Quant: Q4_K_M

  ⚡ SPEED BENCHMARKS
    short_50    TPS: mean=84.2   TTFT: mean=0.231s
    medium_200  TPS: mean=85.7   TTFT: mean=0.312s
    long_800    TPS: mean=82.1   TTFT: mean=0.541s
  🔍 Validating speed plausibility...  Confidence: HIGH

  🧠 ABILITY TESTS
    Code Generation (median_of_list)... PASS
    Logic Puzzle (Pet Ownership)....... PASS
    JSON Compliance.................... PASS
    Instruction Following.............. PASS
    Summarization (Key Facts).......... FAIL
    Ability Score: 4/5

  🤖 AGENT FITNESS TESTS
    Task Acknowledgment / Format Adherence / Conciseness: PASS
    Agent Fitness Score: 3/3

  📄 Results saved: ~/benchmarks/gemma-4-31b-it-2026-08-11.json

Le fichier JSON contient toutes les données temporelles brutes, toutes les réponses du modèle ainsi qu’un résumé. Vous pouvez le renvoyer à votre agent et lui demander : « Lequel de nos modèles devrait se charger du traitement massif de fichiers JSON ? »

Ce que teste bench-llm

Vitesse

Il envoie trois longueurs de prompt (environ 50, 200 et 800 caractères), effectue des exécutions de mise en chauffe, puis mesure trois indicateurs. Le TTFT (temps jusqu’au premier token) correspond au délai d’attente avant l’apparition du texte ; plus de 500 ms donne une impression de lenteur dans un chat. Le Débit (tokens/seconde) indique la vitesse à laquelle le modèle écrit après avoir commencé. Le Préchargement T/s mesure la rapidité avec laquelle il lit votre prompt.

Il effectue également un contrôle de plausibilité par rapport aux limites matérielles connues. Si un modèle de 30 Go prétend atteindre 200 T/s sur une carte 7900 XTX, bench-llm signale ce chiffre, car le décodage spéculatif ou un cache déjà chauffé a probablement faussé les résultats.

Capacités

  • Génération de code : écrire median_of_list(numbers) en gérant les cas limites. bench-llm exécute la fonction sur six cas de test au lieu de se contenter de lire le texte.
  • Problème logique : un casse-tête concernant quatre personnes et leurs animaux domestiques. Le vérificateur extrait les quatre affectations du texte de réponse.
  • Conformité JSON : renvoyer un objet contenant des clés exactes. C’est le minimum requis pour qu’un modèle puisse être utilisé dans des appels d’outils.
  • Respect des instructions : lister les nombres de 1 à 10, marquer les pairs et en calculer la somme. Le calcul est simple ; c’est le format qui constitue le test.
  • Résumé : condenser un paragraphe dense tout en conservant six faits spécifiques. La plupart des modèles en omettent au moins un.

Adaptabilité en tant qu’agent

Le modèle reçoit une tâche réaliste d’agent : rechercher dans les journaux système les lignes contenant « ERROR », les regrouper par service et renvoyer un rapport au format JSON. Trois critères évaluent cette seule réponse :

  • Reconnaissance de la tâche : le modèle décrit-il une approche et mentionne-t-il ce qu’il ne peut pas faire ? Un modèle qui invente des lignes de journal échoue.
  • Respect du format : y a-t-il un tableau services, un entier total_errors et une chaîne de caractères scan_period ?
  • Concision : rapport entre la longueur de la réponse et celle du prompt. Une réponse de 20 000 caractères pour un prompt de 1 300 caractères est qualifiée de « VERBOUSE », car un agent trop bavard remplit rapidement sa fenêtre de contexte à chaque tour.

Comment cela a été construit

Notre consigne adressée à l’agent de codage se résumait en une phrase : « Nous avons besoin d’un outil qui évalue les modèles locaux dans LM Studio, teste leur vitesse et leurs capacités, puis génère un fichier JSON ainsi qu’un tableau. » L’agent a créé cet outil en quatre étapes au cours d’un seul après-midi : des tests de vitesse via l’API de streaming compatible OpenAI de LM Studio, puis des tests de capacités, ensuite la mise en œuvre des fonctionnalités demandées, et enfin des retouches (trouver le fichier GGUF sur le disque, effectuer la vérification de plausibilité, --quick, --list, --check). L’agent a écrit chaque ligne de code. Notre rôle s’est limité à exécuter le programme sur de vrais modèles et à donner notre retour. La vérification de plausibilité a été ajoutée parce que nous avions indiqué à l’agent qu’une certaine valeur de débit était impossible pour un modèle de 123 milliards de paramètres.

Quelques choix de conception dignes d’être repris dans vos propres outils :

  • Utilisez le streaming, pas les requêtes répétées. Le chronométrage par token est le seul moyen d’obtenir un TTFT fiable.
  • Exécutez le code. Un code qui semble correct mais ne fonctionne pas doit être considéré comme un échec, et non comme un succès.
  • Extrayez la réponse avant de la vérifier. Les outils de vérification suppriment les préambules tels que « Bien sûr ! Voici votre réponse : ». Ainsi, le test évalue uniquement le contenu, et non ces introductions superflues.
  • Démarrez chaque exécution avec un GPU vide. Sinon, le cache du modèle précédent fausse les mesures de TTFT. La manière dont bench-llm procède à cela constitue d’ailleurs la première difficulté mentionnée ci-dessous.

Configuration

# 1. Install both dependencies (requests reads LM Studio's model metadata;
#    without it every model shows as "not found")
pip install openai requests

# 2. Start LM Studio with at least one model; it listens on localhost:1234

# 3. Run it
./bench-llm --list                         # what's available
./bench-llm gemma-4-31b-it --quick         # smoke test
./bench-llm gemma-4-31b-it                 # full benchmark

Il n’y a ni fichiers de configuration ni base de données. LM Studio accepte n’importe quelle chaîne de caractères comme clé API. Les résultats sont enregistrés dans ~/benchmarks/. Copiez le script dans un dossier figurant sur votre PATH si vous souhaitez le exécuter depuis n’importe où.

Pièges à éviter

  • Le script met fin à llama-server. Pour chaque exécution, il lance pkill -f llama-server et attend que LM Studio indique qu’aucun modèle n’est chargé. Tout autre processus llama-server en cours sur la machine est également arrêté. Ne l’exécutez pas sur une machine servant d’autres fonctions, ou supprimez cette étape.
  • Le test de codage exécute la sortie du modèle via exec(). Il utilise un espace de noms vierge, qui ne constitue pas un sandbox. Exécutez-le en tant qu’utilisateur sans rien à perdre, ou sautez les tests de capacités avec --speed-only.
  • Les modèles de raisonnement semblent lents. Le temps d’attente jusqu’au premier token (TTFT) inclut ce premier token, y compris s’il s’agit d’un token de type “pensée”. Le JSON sépare ensuite ce temps en ttft_reasoning_s et ttft_content_s.
  • Un score de 4/5, avec uniquement l’échec du résumé, est un excellent résultat. Presque tous les modèles omettent au moins un fait.
  • Une exécution complète prend 2 à 5 minutes par modèle. Utilisez --quick pour comparer plusieurs modèles, puis lancez le test complet sur les meilleurs d’entre eux.
  • LM Studio doit déjà être en cours d’exécution. Le script bench-llm se connecte à localhost:1234 et ne démarre rien de lui-même.

Résultats : modèles de base sur notre rig et mini PC

Ces chiffres proviennent du jeu de tests intermédiaire qui a suivi bench-llm (même méthode de mesure de la vitesse, plus de tests ; rapport daté du 18 août 2026). Le « rig » est une unité GPU sans écran équipée de 2× RTX 5090 et 2× RTX 3090. L’« APU » désigne la GPU intégrée du mini PC (lorsque celui-ci exécutait encore un serveur de modèles locaux). Comparez les vitesses uniquement au sein d’un même appareil. Les colonnes « Code », « Tools », « Instruct » et « Reason » indiquent les taux de réussite.

ModèleAppareilTokens générés/sTTFTCodeOutilsInstructRaisonnement
Gemma 4 26B-A4B (QAT, Q4)Rig229,0110 ms88%100%50%95%
Nemotron 3 Nano 4B (Q8)APU18,5175 ms92%70%94%95%
Gemma 4 12BAPU10,1633 ms————

Le modèle Gemma 4 26B à mélange d’experts (avec 4 milliards de paramètres actifs) est le modèle principal utilisé quotidiennement sur le rig : il génère 229 tokens par seconde, met 110 ms pour produire le premier token et assure un appel aux outils quasi parfait. Son point faible réside toutefois dans le respect des instructions, élément essentiel pour le bon fonctionnement d’un agent autonome. Le modèle Nemotron 4B sur le mini PC suit mieux les instructions (94 % contre 50 %). Toutefois, il est environ douze fois plus lent (18,5 contre 229 tokens/s), et tourne sur un autre appareil. Choisissez donc le modèle en fonction des exigences spécifiques de votre charge de travail, et non simplement du chiffre de vitesse le plus élevé.

Ce qui l’a remplacé : CrucibleForge

bench-llm a disparu suite à son propre succès. Cinq tests d’aptitude suffisent pour créer un bon détecteur de fumée, mais ne permettent pas d’établir de véritable classement : une fois que tous les modèles obtiennent 5/5 et 3/3, l’outil n’a plus rien à dire. CrucibleForge en est la réécriture. Il compte désormais environ 12 000 lignes de code Python ; sa règle fondamentale est que une question difficile doit rester facile à évaluer.

  • 166 cas difficiles. Problèmes mathématiques de compétition avec des réponses entières, grilles logiques nécessitant une solution unique, ainsi que des exercices de programmation dont les tests imposent une complexité minimale (un algorithme en O(n²) pour compter les inversions ne passe pas le test). On trouve aussi des pièges liés à l’utilisation d’outils, avec des outils trompeurs et tentatives d’injection de prompts ; il s’agit également de tests de récupération d’information dans un contexte long (12 000 à 24 000 tokens) ainsi que d’instructions multi-contraintes.
  • Le code est évalué en le faisant tourner dans un bac à sable bwrap sans connexion réseau, avec un système en lecture seule et une limite de 15 secondes. Pour être validé, le programme doit afficher une chaîne de caractères spécifique sur stdout ; il ne peut donc pas simuler un succès en renvoyant simplement la valeur zéro. Sans bwrap (ce qui est toujours le cas sous macOS et Windows), l’outil refuse d’exécuter le code du modèle sauf si vous spécifiez --allow-unsandboxed.
  • Les réponses en prose disposent d’une réponse de référence. Le modèle-juge a accès à cette réponse correcte et se contente de déterminer si la réponse fournie a le même sens. N’importe quel modèle instruct compétent peut accomplir cette tâche ; ainsi, le modèle-juge cesse d’être le maillon faible du système.
  • Tout point de terminaison compatible OpenAI est accepté. LM Studio, Ollama, llama.cpp, vLLM, DeepSeek, OpenRouter, etc. Les modèles hébergés traitent les cas en parallèle et communiquent le coût en tokens. Les clés API ne sont lues que depuis les variables d’environnement.
  • L’outil récupère les réponses que les modèles de raisonnement perdent. Un modèle de raisonnement qui consomme tout son budget de calcul renvoie souvent une réponse vide. CrucibleForge détecte ce cas, relance le test sans activation du raisonnement, puis comptabilise la fréquence de tels événements. recover permet de relancer uniquement ces lignes issues d’une exécution antérieure.
  • Il partage les GPU de manière courtoise. Sur notre plateforme StudioForge, chaque exécution demande les cartes graphiques dont elle a besoin, puis les libère une fois terminée. Avant cela, bench-llm utilisait pkill pour mettre fin à tous les modèles en cours d’exécution.
  • Une interface web accessible sur 127.0.0.1:8777 permet de sélectionner les modèles et les catégories, de consulter les journaux d’exécution et d’ouvrir chaque ligne en échec : prompt, réponse, raisonnement du modèle ainsi que le commentaire du modèle-juge. Une clé d’authentification est requise pour accéder à cette interface en dehors de l’adresse loopback.

Essayez-le

La méthode la plus simple est d’utiliser Docker, car le conteneur sert également de sandbox pour le code généré par les modèles. Sur Linux, une fois Docker installé :

git clone https://github.com/LaserLloyd/CrucibleForge.git && cd CrucibleForge
cp deploy/compose/.env.example deploy/compose/.env    # LLM_BASE_URL defaults to port 1234 on the Docker host
docker compose -f deploy/compose/compose.yml up -d
docker compose -f deploy/compose/compose.yml logs app | grep "GUI:"   # open the printed http://127.0.0.1:8777/?token=... URL

Ou bien en mode natif ; sur Linux, cela assure un isolement grâce à bwrap pour les cas de codage :

sudo apt-get install -y bubblewrap
git clone https://github.com/LaserLloyd/CrucibleForge.git && cd CrucibleForge
uv sync --python 3.13
uv run crucibleforge config --init      # writes models.yaml; set base_url to your server's /v1
uv run crucibleforge status             # is the provider up? how many cases?
uv run crucibleforge all --models my-model --fresh --yes
uv run crucibleforge gui                # http://127.0.0.1:8777

Indiquez --python 3.13 : sur une machine brute, la commande uv sync peut sélectionner une version plus récente de Python que celle supportée par le projet. Sur macOS et Windows, il n’y a pas de bwrap ; dans ce cas, les exécutions natives nécessitent --allow-unsandboxed avant la sous-commande (le code généré par le modèle s’exécute alors en votre nom), ou bien il faut utiliser Docker Desktop. Si votre serveur de modèles exige une clé API, indiquez le nom de cette variable dans api_key_env pour ce fournisseur dans le fichier models.yaml ; la clé elle-même reste définie dans l’environnement.

all exécute le seul benchmark défini, profiles/bench.yaml : 49 cas sélectionnés comme étant le plus petit ensemble capable de distinguer les modèles, suivis de l’évaluation et de la compilation des résultats. Chaque modèle reçoit deux scores compris entre 0 et 100. Le score Coding provient d’évaluateurs déterministes (programmes, utilisation d’outils, suivi d’instructions, raisonnement et mathématiques). Le score Chat évalue l’écriture, le jeu de rôle et la capacité à orienter le comportement du modèle ; il inclut également des catégories à contenu pour adultes non abordées ici. Les 276 autres cas restent disponibles dans la suite afin d’effectuer des exécutions ciblées via --cases ou --categories. Les autres commandes sont run, judge, recover, report, pairwise, models, bench-all, import-openclaw et cases.

Le tableau de bord web de CrucibleForge 3.6.0 avec la configuration exemple fournie : un tableau des fournisseurs où lmstudio, ollama, llamacpp et openwebui sont marqués comme DOWN, tandis que les fournisseurs hébergés sont marqués UP sans clés API définies ; un panneau d’évaluation indiquant le juge du benchmark et quatre candidats de secours ; enfin, un tableau listant 276 cas, dont 166 difficiles, classés par catégorie
Interface graphique sur une copie fraîchement clonée, avec le fichier models.yaml exemple et aucun résultat : on y voit quels fournisseurs répondent, quel juge évalue le benchmark, ainsi que l’ensemble des cas (276 au total, dont 166 difficiles). Aucun processus local n’étant en cours d’exécution, les statuts sont marqués DOWN.

La commande à laquelle nous faisons le plus confiance est celle qui vérifie les questions elles-mêmes. Elle exécute chaque solution de référence dans la sandbox, recalcule manuellement chaque réponse mathématique et reconstitue chaque ensemble de données à contexte long. Voici son output sur une copie propre de la version 3.6.0, en date du 19 octobre 2026 :

$ uv run crucibleforge cases verify
276 cases checked, 0 with problems (36 reference solutions executed, 37 answers re-derived)

La suite de tests effectue le même contrôle ; ainsi, une question défectueuse ne peut pas échouer discrètement pour tous les modèles tout en étant considérée comme correcte pour un niveau de difficulté élevé.

Nouveautés dans la version 3.6

CrucibleForge 3.6.0 (18 octobre 2026) modifie la manière dont le projet s’installe et s’exécute, mais pas ce qu’il mesure. Aucun cas de test, aucun correcteur ni aucune métrique n’a été changé ; les résultats marqués comme provenant de la version 3.5.1 sont considérés comme appartenant au même ensemble de cas de test. Par conséquent, rien sur les tableaux de bord existants ne devient obsolète.

  • Docker. Une image en lecture seule, exécutée sans droits root, d’environ 190 Mo. L’interface graphique est accessible via 127.0.0.1:8777, tandis que votre fichier models.yaml ainsi que les résultats se trouvent sur un volume qui subsiste après les mises à jour. À l’intérieur du conteneur, les cas de test s’exécutent sans bwrap, car le conteneur lui-même constitue l’environnement isolé ; il peut néanmoins accéder au réseau. Il convient donc de le considérer comme un endroit où du code non fiable peut s’exécuter.
  • Windows. La suite de tests fonctionne correctement sous Windows, et les systèmes d’intégration continue disposent désormais d’une étape dédiée à Windows. Une limitation cependant : le mécanisme empêchant l’exécution simultanée de deux benchmarks n’est pas activé sous Windows ; il faut donc lancer un seul benchmark à la fois.
  • Test d’isolement automatique. Un outil bwrap installé mais incapable d’assurer réellement l’isolement (dans un conteneur ou lorsque les espaces de noms utilisateur sont bloqués) est détecté avant le début de l’exécution. L’exécution est alors refusée (ou, avec --allow-unsandboxed, elle se déroule sans isolation et en informe clairement l’utilisateur), plutôt que de faire échouer tous les cas de test.
  • Clés API et messages d’erreur plus clairs. status indique si un serveur renvoie un code 401 ou 403, et précise quelle variable il faut configurer. Cela correspond exactement aux besoins du passerelle StudioForge 2.0 en matière de gestion des clés API.
  • Correction du 19 octobre 2026 : auparavant, le bouton « Judge pending rows » de l’interface graphique utilisait un correcteur de secours dont les décisions n’étaient pas prises en compte dans les tableaux de bord. Désormais, il fait appel au correcteur propre au benchmark, comme c’était déjà le cas en ligne de commande ; le tableau de bord indique également le nom de ce correcteur.

Mise à jour. De manière standard, exécutez git pull && uv sync --python 3.13. Si votre fichier models.yaml oriente StudioForge vers le port 8080, modifiez-le afin qu’il pointe vers le port 1234 : le port 8080 est réservé au panneau de contrôle de StudioForge, tandis que l’API se trouve sur le port 1234. Un fichier models.yaml déjà existant ne sera jamais écrasé automatiquement. En environnement Docker, utilisez git pull, puis docker compose -f deploy/compose/compose.yml up -d --build ; le volume de données est conservé, et la commande down -v suffit à le supprimer.

À quoi ressemble un rapport

report génère un fichier Markdown et un fichier JSON. Chaque modèle dispose d’une ligne de résumé ainsi que d’une ligne par catégorie indiquant les compteurs bruts. Voici la ligne par catégorie pour DeepSeek V4 Pro :

| Model        | Coding      | Math        | Tool use    | Instruction  | Reasoning    | Long-context |
| deepseek-pro | 89% (54/61) | 95% (21/22) | 94% (31/33) | 100% (31/31) | 100% (37/37) | 97% (29/30)  |

Chaque échec est listé avec sa raison. Les sept échecs en matière de programmation ressemblent tous à la première ligne ci-dessous. La deuxième ligne représente l’un des deux cas où le modèle n’a pas su utiliser les outils :

- deepseek-pro [coding] CZ01-prime-census: TRUNCATED at 32768 tokens (32768 reasoning tokens); no code in response
- deepseek-pro [tooluse] TZ06-three-parallel-one-turn: 1 calls, expected 3

C’est là que réside l’intérêt du rapport. Le modèle n’a pas écrit de mauvais code ; il a simplement réfléchi jusqu’à épuisement du budget de 32 768 tokens, sans jamais produire quoi que ce soit. Un budget plus important ou un niveau d’effort de raisonnement inférieur auraient probablement changé ce résultat. Le taux de réussite seul ne permettrait pas de le savoir.

Les modèles hébergés bénéficient également d’une indication Coût d’exécution dans le rapport : il s’agit du prix d’une exécution des tests standards (voir la documentation MakoBench).

Résultats du niveau difficile

Voici le tableau tel qu’il était le 2026-11-09, reconstitué à partir de l’exécution du 2026-11-08 sur la suite 4.1.0 et évalué par gemma-4-31B. Le système de notation est celui décrit ci-dessus : chaque catégorie est notée sur 10 lors du test standard ; la note globale est sur 20 (programmation + conversation). Une catégorie ne dépasse pas 10 que si un « pack d’épreuves supplémentaires » est débloqué — trois questions plus difficiles, rapportant chacune 1 point, attribuées uniquement après avoir atteint 90 % de réussite dans toutes les autres catégories. La partie « Programmation » est déterministe (fonctions, prédiction, détection de bugs, utilisation d’outils) ; la partie « Conversation » est évaluée par le juge (jeux de rôle complexes, dialogue, création littéraire). Le ± après chaque note représente la moitié de l’intervalle à 90 % obtenu via une méthode bootstrap sur l’ensemble des cas testés ; ainsi, deux modèles dont les intervalles se chevauchent sont considérés comme à égalité, et non classés.

Classe indique la catégorie générale dans laquelle se situe la note (S à partir de 16, A à partir de 13, B à partir de 10). Lignes terminées représente le pourcentage de lignes ayant été exécutées dans les limites du budget de sortie standard ; toute ligne dépassant ce budget est considérée comme échouée. Certaines lignes font encore l’objet d’une nouvelle tentative, donc certaines notes peuvent encore évoluer. Coût d’exécution correspond au coût d’une exécution standard selon les tarifs du fournisseur, uniquement pour la génération de texte ; le jugeage est effectué sur nos propres cartes graphiques. Le rapport indique également une vitesse de génération médiane, mais celle-ci n’est comparable qu’entre modèles exécutés sur le même hôte ; comme ici les machines proviennent de fournisseurs différents, nous ne la mentionnons pas.

Jugement tout frais — et un match nul pour l’ensemble du tableau

  • Une seule exécution, un seul juge, un seul jour. Les 26 lignes ci-dessous ont toutes été exécutées et évaluées le 2026-11-08, sur la suite 4.1.0, avec gemma-4-31B comme juge.
  • Le test comparatif intégré au tableau ne permet pas de distinguer deux modèles quels qu’ils soient. L’intervalle à 90 % de chaque paire adjacente contient zéro, et ces égalités se propagent jusqu’en bas du tableau ; le rapport attribue donc à toutes les 26 lignes la même catégorie de classement. Les valeurs allant de 19,3 à 11,3 doivent être considérées comme des estimations ponctuelles, et non comme un véritable classement.
  • MiniMax M3 obtient enfin une note évaluée. Le tableau précédent ne lui attribuait qu’une note en programmation, sans note globale. Ici, il atteint 14,6 ± 1,7 ; la colonne « Room » du rapport indique même 15,5 après réexécution de ses deux lignes ayant dépassé le budget — une autre tentative reste encore en attente. À environ 0,57 $ par exécution, son coût représente un septième de celui du modèle le plus cher.

Niveau difficile — tableau complet de 26 modèles

ModèleNote globaleProgrammationConversationClasseLignes terminéesCoût d’exécution
Kimi K3.1 Pro19,3 ± 0,510,0 ± 0,19,3 ± 0,5S100%4,07 $
Grok 4.719,2 ± 0,310,0 ± 0,19,2 ± 0,3S100%3,91 $
Claude Opus 5.519,2 ± 0,510,0 ± 0,19,2 ± 0,5S100%4,50 $
DeepSeek V4 Flash18,8 ± 0,811,2 ± 0,47,6 ± 0,6S92% (4 ont dépassé le budget)0,14 $
Claude Sonnet 5.518,6 ± 0,410,0 ± 0,18,6 ± 0,4S100%2,36 $
GPT-6.1 Terra17,9 ± 1,09,4 ± 0,68,5 ± 0,7S100%0,63 $
DeepSeek V4 Pro17,8 ± 0,710,1 ± 0,57,7 ± 0,4S89% (5 ont dépassé le budget)0,57 $
GPT-6 Luna17,7 ± 0,69,7 ± 0,28,0 ± 0,5S100%0,08 $
Claude Opus 516,7 ± 1,48,3 ± 1,28,4 ± 0,4S100%5,07 $
Claude Opus 4.816,3 ± 0,69,2 ± 0,57,1 ± 0,4S100%4,37 $
Claude Fable 5.116,1 ± 0,97,7 ± 0,58,4 ± 0,7S100%10,23 $
Claude Opus 4.716,1 ± 0,89,3 ± 0,66,8 ± 0,5S100%4,75 $
Claude Fable 516,0 ± 1,97,5 ± 1,98,5 ± 0,6S100%9,70 $
Claude Haiku 5.515,3 ± 1,19,2 ± 0,76,1 ± 0,9A100%0,11 $
Claude Opus 4.615,3 ± 1,38,0 ± 1,37,3 ± 0,3A100%3,38 $
Claude Sonnet 515,3 ± 0,98,8 ± 0,86,4 ± 0,4A100%2,81 $
Claude Sonnet 4.614,6 ± 1,67,6 ± 1,47,0 ± 0,7A97% (1 a dépassé le budget)2,98 $
MiniMax M2.5 Highspeed14,6 ± 0,88,3 ± 0,76,3 ± 0,4A100%~0,63 $
MiniMax M314,6 ± 1,78,5 ± 0,86,0 ± 1,4A94% (2 ont dépassé le budget)~0,57 $
Claude Opus 4.513,8 ± 1,47,1 ± 1,26,7 ± 0,7A100%3,27 $*
MiniMax M3.1 Flash13,6 ± 1,78,0 ± 0,95,6 ± 1,4A94% (2 ont dépassé le budget)~0,28 $
MiniMax M2.713,4 ± 1,76,7 ± 1,66,7 ± 0,5A100%~0,30 $
MiniMax M2.7 Highspeed13,2 ± 1,27,6 ± 0,95,6 ± 0,8A100%~0,62 $
Claude Sonnet 4.513,2 ± 1,16,4 ± 1,16,8 ± 0,4A100%1,94 $*
MiniMax M2.512,2 ± 1,86,4 ± 1,65,8 ± 0,8B100%~0,31 $
Claude Haiku 4.511,3 ± 1,25,7 ± 1,05,6 ± 0,6B100%0,63 $*

Résumé des coûts : une exécution standard de l’ensemble des 26 lignes a coûté 68,21 $ en jetons fournis par les prestataires, uniquement pour la génération de texte ; le jugement est effectué sur nos propres cartes graphiques. La catégorie « contenu pour adultes », non traitée dans cette page, fait l’objet d’un tarif distinct. Douze des 26 lignes ont coûté moins d’un dollar, soit 4,87 $ au total ; les 14 autres représentent 63,34 $, dont 19,93 $ pour les deux modèles les plus chers : Claude Fable 5.1 et Claude Fable 5. Six des montants indiqués sont des estimations basées sur le nombre de jetons plutôt que des coûts réellement facturés ; trois portent un astérisque car certaines requêtes n’ont pas renvoyé de données d’utilisation, donc le total réel est légèrement supérieur.

Ce qui ne figure pas dans le tableau. Trente-deux lignes correspondent à des modèles fine-tunés exécutés sur nos propres cartes ; le rapport les marque toutes comme « partielles » car elles n’ont pas traité l’ensemble du jeu de tests standard ; aucune ne dispose donc de note globale ni de classement. Quatre d’entre elles ont également complètement échoué : trois n’ont pas obtenu de licence GPU, et une a été interrompue en cours d’exécution. Huit modèles hébergés sont également en attente : pour trois, le juge n’a pas encore évalué vingt lignes ; cinq ont été rejetés par leur fournisseur avant même de pouvoir s’exécuter. Chaque ligne listée ci-dessus comporte encore quelques verdicts issus de l’ancien système de notation, en attente d’une nouvelle évaluation ; ces notes peuvent donc légèrement varier.

Les lignes hébergées portent le nom de leurs produits respectifs. Vingt-quatre lignes combinent des résultats de la suite 4.0.1 avec ceux de cette exécution sur la suite 4.1.0 ; DeepSeek V4 Flash et DeepSeek V4 Pro intègrent également des données de la version 3.9.0. Un « ~ » indique qu’il s’agit d’une estimation basée sur le nombre de jetons au tarif catalogue ; un astérisque signifie que certaines requêtes n’ont pas fourni de données d’utilisation, donc le montant pourrait être sous-estimé. Quatre lignes en attente portent des identifiants de registre faisant référence à des modèles retirés dont le nom n’est pas affiché sur ce site.

Ce que l’on peut en déduire :

  • Aucun modèle ne prend la tête du classement. Pour chaque paire adjacente, l’intervalle à 90 % contient zéro ; ces égalités se propagent de la première à la dernière ligne, d’où l’attribution identique de toutes les 26 lignes. La différence de huit points entre les 19,3 de Kimi K3.1 Pro et les 11,3 de Claude Haiku 4.5 n’est qu’une estimation ponctuelle dans ce contexte.
  • Le coût est le facteur qui les différencie réellement. Une exécution standard des 26 modèles coûte 68,21 $. DeepSeek V4 Flash obtient 18,8 points pour seulement 0,14 $ ; Claude Fable 5.1 ne décroche que 16,1 points pour 10,23 $, soit environ 85 fois moins de points par dollar. Douze modèles coûtent moins d’un dollar, dont quatre atteignent au moins 16 points.
  • La programmation détermine le haut du tableau, pas la conversation. Seuls DeepSeek V4 Flash (11,2) et DeepSeek V4 Pro (10,1) dépassent 10 en programmation, et ce sont eux qui ont débloqué les packs d’épreuves supplémentaires ; aucun modèle ne franchit 10 en conversation, où le meilleur score est de 9,3 pour Kimi K3.1 Pro. Pour intégrer un modèle dans un agent, c’est la colonne « Programmation » qui importe.
  • Le budget de sortie constitue un filtre silencieux. Cinq lignes ont dépassé leur budget : DeepSeek V4 Pro (5 lignes), DeepSeek V4 Flash (4), MiniMax M3 et MiniMax M3.1 Flash (2 chacun) ainsi que Claude Sonnet 4.6 (1). Sur le tableau, une ligne ayant dépassé son budget est considérée comme échouée. Lorsqu’une nouvelle exécution a lieu, la colonne « Room » indique la note corrigée : MiniMax M3 atteint ainsi 15,5 points (+0,9) et MiniMax M3.1 Flash 14,5 points ; pour DeepSeek V4 Flash et Claude Sonnet 4.6, ces corrections sont encore en attente.
  • Les filtres des fournisseurs font perdre des points. Quatre lignes ont vu leurs réponses bloquées par les filtres de contenu des prestataires : Claude Fable 5 (6), Claude Opus 5 (2), Claude Fable 5.1 (2) et Claude Opus 5.5 (1). Une réponse bloquée vaut zéro point. Cinq lignes présentent également un verdict que le juge n’a pas pu interpréter.

Téléchargement

Le fichier téléchargeable est bench-llm, l’original désormais obsolète, et non CrucibleForge (disponible sur GitHub). Le fichier ZIP contient deux éléments : bench-llm, le script de 1 660 lignes, et README.md qui rassemble les instructions de configuration. Il n’y a rien à compiler ou à installer en plus de ces deux fichiers : il suffit de décompresser puis d’exécuter le script. L’IA a rédigé ces deux fichiers, qui sont tous deux sous licence MIT. Les dépendances nécessaires sont openai et requests. Veuillez lire les précautions avant de l’exécuter sur une machine hébergeant d’autres services.

Voir aussi : StudioForge (le serveur GPU dont ces modèles utilisent les cartes graphiques), Ce que mes agents IA coûtent réellement (pourquoi la vitesse locale est importante), DeepSeek Harness (un agent de codage soutenu par ces modèles), ainsi que la pile d’agents IA locale sur laquelle ils fonctionnent.

Téléchargements

Gratuit pour un usage personnel. Si ça vous fait gagner un après-midi, le bouton café n'est pas loin.


← Plus de IA et LLM locaux More MakoBench articles →