LLM le moins cher pour les agents IA : 30 modèles classés par coût par exécution

En laissant de côté les modèles de niveau D ci-dessous, le modèle le moins cher capable d'exécuter un agent d'appel d'outil est désormais Claude Haiku 5.5, à 0,10 $ en entrée / 0,50 $ en sortie par million de tokens, soit 0,0185 $ pour une exécution de référence en 12 étapes ; GPT-6 Luna coûte le même prix. Le plus grand appel dans cette exécution est de 23 800 tokens, bien en dessous du seuil de 100 000 tokens où Haiku 5.5 facture 0,50 $ / 2,50 $. DeepSeek V4.1 Flash coûte 0,027 $ hors pointe (0,15 $ / 0,60 $) ; aux heures de pointe de DeepSeek, il coûte 0,30 $ / 1,20 $, soit 0,054 $, et GPT-5.4 nano (0,038 $) est moins cher. V4.1 Flash a remplacé V4 Flash, que DeepSeek a retiré ; son nom d'API est deepseek-flash. Le modèle le moins cher que nous exécuterions sans surveillance en production est Gemini 3.8 Flash (0,75 $ / 3,75 $) ou GPT-5.4 mini (0,75 $ / 4,50 $) à environ 0,14 $ par exécution. Le modèle phare le moins cher est Claude Sonnet 5 (2 $ / 10 $) à 0,37 $. Les prix sont en USD par million de tokens de notre catalogue en date du 11/09/2026 ; Claude Haiku 5.5 vérifié le 03/11/2026 sur la page de tarification d'Anthropic. Tarification DeepSeek vérifiée le 27/10/2026 sur api-docs.deepseek.com ; le tarif hors pointe est la moitié du tarif de pointe (pointe de 01:00 à 04:00 et de 06:00 à 10:00 UTC en semaine).

L'exécution de référence : une invite système de 4 000 tokens plus les définitions d'outils envoyées à chaque étape, un résultat d'outil de 1 500 tokens ajouté après chaque étape, 300 tokens de sortie par étape, 12 étapes. Comme chaque étape renvoie l'historique complet, le contexte à l'étape k est de 4 000 + (k - 1) × 1 800 tokens, et les totaux de l'exécution sont :

• Input tokens = 12 × 4,000 + 1,800 × 12 × 11 ÷ 2 = 48,000 + 118,800 = 166,800
• Output tokens = 12 × 300 = 3,600
• Run cost = 166,800 × (input rate ÷ 1,000,000) + 3,600 × (output rate ÷ 1,000,000)

Pour Claude Sonnet 5 : 0,3336 $ + 0,036 $ = 0,3696 $. L'entrée représente 90 % ou plus de l'exécution sur chaque modèle, donc le classement suit le prix d'entrée. La formule générale pour N étapes se trouve dans combien coûte l'exécution d'un agent IA.

Aucune mise en cache ou remise par lot appliquée. Multipliez la dernière colonne par 1 000 pour un budget mensuel à 1 000 exécutions. Claude Haiku 5.5 (sorti le 7 octobre 2026) remplace l'ancien Claude Haiku 4.5, qui coûte encore 1 $ / 5 $, soit 0,1848 $ par exécution, dix fois plus.

L'écart entre le rang 1 et le rang 29 est de 83×. La mise en cache des invites le réduit sans le réordonner : avec des lectures de cache à environ 10 % du prix catalogue chez Anthropic et OpenAI et environ 25 % chez Gemini, Sonnet 5 tombe à environ 0,12 $ et Gemini 3.8 Flash à environ 0,06 $ par exécution. Les lignes en direct sont sur la page des modèles.

Le prix est la moitié facile. Un modèle d'agent doit émettre un appel d'outil qui correspond au schéma, choisir le bon outil, s'arrêter une fois terminé et ne pas boucler. Les niveaux ci-dessous sont notre lecture éditoriale de l'échafaudage dont chaque modèle a besoin dans une boucle de production, pas un benchmark ; exécutez votre propre évaluation sur vos propres schémas avant de vous engager.

• Niveau A, exécution sans surveillance avec validation normale : Claude Opus 5, GPT-5.5, GPT-5.4, Gemini 3.1 Pro, Claude Sonnet 5. Adhérence cohérente au schéma, bon comportement d'arrêt, moins d'étapes gaspillées.
• Niveau B, exécution sans surveillance avec schémas stricts : Claude Haiku 4.5 (désormais ancien), GPT-5.4 mini, Gemini 3.8 Flash, GPT-5.3-Codex et Devstral 2 (boucles de codage), DeepSeek V4 Pro, Kimi K2.6, Qwen 3.8 Max, Grok 4.6, Mistral Large 3.
• Niveau C, exécution avec validation, tentatives et chemin d'escalade : GPT-5.4 nano, Gemini 3.5 Flash Lite, DeepSeek V4.1 Flash, GLM 4.7, MiniMax M2.7, Qwen3 Coder 480B, Llama 4 Maverick, Codestral 2508, Mistral Medium 3.1. Attendez-vous à des arguments malformés, des choix d'outils erronés sur de grands ensembles d'outils et des dépassements du nombre d'étapes sur des tâches ouvertes.
• Niveau D, pas comme planificateur : Llama 4 Scout, GLM 4.7 Flash, GPT-4.1 mini (génération précédente). Convient pour la classification unique dans une boucle pilotée par quelqu'un d'autre.

Le modèle le moins cher qui fait encore cela de manière fiable est Gemini 3.8 Flash ou GPT-5.4 mini à environ 0,14 $ par exécution. Chez Anthropic, Claude Haiku 5.5 à 0,0185 $ est maintenant un dixième du prix de l'ancien Haiku 4.5 à 0,185 $ ; jusqu'à ce qu'il ait gagné un niveau, exécutez-le comme première tentative derrière un validateur. En dessous de 0,10 $ par exécution, vous achetez un modèle qui a besoin d'un superviseur, et le coût du superviseur fait partie de votre nombre par tâche.

Le gagnant du coût par tâche n'est presque jamais un modèle unique. Il s'agit d'un modèle de Niveau C ou B pour la première tentative, d'un validateur qui vérifie l'appel d'outil et le résultat final, et d'un modèle de Niveau A qui ne prend le relais que lorsque la tentative économique échoue. Un client compatible OpenAI via OpenRouter transforme cette échelle en une simple liste de noms de modèles (voir notre comparaison OpenRouter vs API directe pour la marge de routage).

from openai import OpenAI
client = OpenAI(base_url="https://openrouter.ai/api/v1", api_key=KEY)

LADDER = [  # (model, $ in per 1M, $ out per 1M)
    ("deepseek/deepseek-v4.1-flash", 0.30, 1.20),   # peak rate
    ("google/gemini-3.8-flash", 0.75, 3.75),
    ("anthropic/claude-sonnet-5", 2.0, 10.0),
]

def run_task(task, max_steps=12, budget_usd=0.60):
    spent = 0.0
    for model, p_in, p_out in LADDER:
        history = [{"role": "user", "content": task}]
        for _ in range(max_steps):
            r = client.chat.completions.create(model=model, messages=history,
                                               tools=TOOLS, max_tokens=2000)
            u = r.usage
            spent += (u.prompt_tokens * p_in + u.completion_tokens * p_out) / 1e6
            if spent > budget_usd:
                return None, spent                # hard cap: give up
            ok, done = apply_tool_calls(r, history)   # validate + execute
            if not ok:
                break                             # schema/tool failure: escalate
            if done and validate_result(history):
                return history[-1], spent         # success on this rung
    return None, spent

validate_result doit être un test déterministe peu coûteux confirmant que la tâche est bien terminée (les tests réussissent, l'enregistrement existe, le JSON correspond), et spent est partagé sur chaque marche de l'échelle. Sans validateur, l'échelle se contente de transmettre les échecs vers les niveaux supérieurs.

Coût par tâche réussie = coût par exécution ÷ taux de réussite, plus le coût d'escalade ou de relance lorsque l'exécution échoue. Un exemple concret avec des taux de réussite indicatifs (remplacez-les par vos propres chiffres d'évaluation) :

Le routage bat Sonnet 5 seul en termes de dépenses API. Aux tarifs aux heures de pointe de DeepSeek, l'échelle Gemini 3.8 Flash est la moins chère des deux. Trois éléments replacent le modèle phare en tête. Coût d'échec : si une exécution échouée nécessite qu'une personne la remarque et la relance, un taux d'échec à la première tentative de 55 % coûte plus en minutes qu'il n'en économise en dollars. Nombre d'étapes : un modèle bon marché qui nécessite 30 étapes ($0.293 sur Gemini 3.5 Flash Lite) pour accomplir ce que Sonnet 5 fait en 12 ($0.37) a gaspillé son avantage. Effets secondaires : lorsqu'un appel d'outil incorrect envoie un e-mail ou écrit en production, le validateur ne peut pas annuler l'action.

Quand payer pour le modèle phare : en tant que planificateur dans un système multi-agents, sur toute étape ayant des effets secondaires irréversibles, et chaque fois qu'une exécution échouée coûte plus d'environ $0.50 du temps de quelqu'un. Quand ne pas payer : sur la majorité des étapes routinières, où le Tier B à $0.14 avec des schémas stricts est le bon choix par défaut.

Toute boucle d'agent a besoin de quatre limites quel que soit le modèle :

• max_tokens par appel de 1 000 à 4 000 pour les tours d'appel d'outils.
• Un plafond d'étapes strict, de 12 à 15 pour la plupart des types de tâches, dans votre boucle ou via la limite de tours du SDK.
• Conditions d'arrêt : un outil de fin obligatoire, un abandon en cas d'appels d'outils identiques répétés, et un abandon en cas de deux erreurs d'outil consécutives.
• Un budget USD par exécution calculé à partir de l'objet d'utilisation après chaque appel, partagé entre les paliers d'escalade comme dans l'extrait ci-dessus.

Plafonds raisonnables par exécution : environ 0,10 $ pour une boucle de niveau C, 0,30 $ pour le niveau B, 1,00 $ pour le niveau A, et 2,00 $ pour une exécution autorisée à escalader jusqu'au bout. Le calculateur de coût IA convertit un nombre mensuel d'exécutions en ligne budgétaire, et les guides de coût de l'API Claude agent, du SDK OpenAI Agents et de l'API Gemini agent couvrent les plafonds spécifiques aux fournisseurs et la syntaxe de cache.

Lignes lancées ou réajustées en septembre, facturées sur la même exécution de référence (166 800 tokens en entrée, 3 600 en sortie), tarifs OpenRouter vérifiés le 1er octobre 2026, sans mise en cache ni traitement par lots.

GPT-6 Luna à $0,0185 coûte environ la moitié de GPT-5.4 nano à $0,038 sur la même exécution. Claude Opus 5.5 à $0,74 coûte moins cher que Claude Opus 5 ($0,92) ou GPT-5.5 ($0,94) et est numéro 1 sur l'Intelligence Index d'OpenRouter, il remplace donc les deux comme échelon phare sur le prix. DeepSeek V4.1 Flash facture selon l'heure de la journée ($0,30 / $1,20 en heures pleines, $0,15 / $0,60 en heures creuses sur la page tarifaire de DeepSeek), donc planifiez les exécutions non supervisées en heures creuses. Mercury 2.5 (80 % de réduction) et Gemini 3.8 Flash (50 % de réduction) sont à des prix promotionnels qui peuvent prendre fin.

Nous n'avons pas encore placé les nouvelles lignes légères (Mercury 2.5, GPT-6 Luna, DeepSeek V4.1 Flash, et le Claude Haiku 5.5 d'octobre au même $0,0185 que GPT-6 Luna) dans les niveaux de fiabilité ci-dessus. Exécutez-les d'abord comme tentatives de niveau C derrière un validateur jusqu'à ce que votre propre évaluation sur vos propres schémas d'outils dise le contraire.

L'API Batch d'OpenRouter (POST https://openrouter.ai/api/v1/batches, disponible depuis septembre) facture la plupart des modèles à environ 50 % du prix par token et renvoie les résultats sous 24 heures. Elle accepte les chat completions, les Responses, les Messages Anthropic et les embeddings.

Elle ne convient pas à la boucle d'agent elle-même : chaque étape dépend du résultat de l'outil précédent, et chaque aller-retour pourrait attendre jusqu'à un jour. Elle convient au travail autour de la boucle, où chaque élément est une requête : évaluations de nuit des exécutions du jour, notation de transcriptions, résumé des sorties d'outils, classification en masse et remises à niveau.

Tarifs batch par 1M : GPT-6 Luna $0.05 / $0.25, Gemini 3.8 Flash $0.375 / $1.875, GPT-6.1 Sol $1 / $5, Claude Opus 5.5 $2 / $10, GPT-6 Astra et Claude Fable 5.1 $5 / $25.

Exemple concret : noter 1 000 exécutions terminées pendant la nuit, chacune avec 1 000 tokens en entrée et 200 en sortie, cela représente 1M d'entrée plus 200K de sortie. Cela coûte $4.00 en interactif ou $2.00 en batch sur GPT-6.1 Sol, $8.00 ou $4.00 sur Claude Opus 5.5, et $20 ou $10 sur GPT-6 Astra.

Contraintes : un seul modèle et une seule forme d'endpoint par batch, texte uniquement, et chaque batch s'exécute sur un seul fournisseur (par défaut l'endpoint batch le moins cher que votre liste blanche de fournisseurs, la politique de données et les paramètres BYOK autorisent). Les modèles xAI bénéficient d'une remise de 20 % en batch au lieu de la moitié. La recherche web et la mise en cache des prompts sont facturées à leurs tarifs habituels, donc la part mise en cache d'un prompt n'est pas réduite de moitié à nouveau.

L'outil de serveur shell hébergé d'OpenRouter (openrouter:shell, ou openrouter:bash pour la forme d'outil Anthropic ; en version bêta) permet à tout modèle appelant des outils d'exécuter des commandes dans un conteneur Linux hébergé. Le temps sandbox coûte $0.0001 par seconde active, facturé à l'intérieur de la requête.

• 10 minutes actives : 600 × $0.0001 = $0.06
• 1 heure active : 3 600 × $0.0001 = $0.36

Sur une exécution de 12 étapes avec GPT-6 Luna ($0.0185), dix minutes de temps shell coûtent plus de trois fois les tokens. Sur Claude Opus 5.5 ($0.74), cela ajoute environ 8 %. Avec des modèles bon marché, le sandbox, et non le modèle, peut être la ligne la plus importante : comptez les secondes actives dans le budget par exécution, limitez le temps d'exécution des commandes, et ne laissez pas de processus longs tourner à l'intérieur d'une requête. L'API Files contient jusqu'à 10 Gio par espace de travail, et les administrateurs d'espace de travail peuvent désactiver les outils serveur.

L'échec le plus coûteux d'un modèle bon marché est un mauvais appel d'outil avec effets secondaires. Le Jev de TypeSafe (typesafe/jev-1.13) est un modèle de décision sur OpenRouter qui répond à des questions typées concernant un appel d'outil en attente au lieu d'écrire du texte : noul (oui/non), choice (choisir une option) ou score (un nombre dans une plage), avec des probabilités et une valeur de confiance sur choice et score. Il coûte $0.042 par million de tokens en entrée avec sortie gratuite, et toute clé OpenRouter fonctionne. OpenRouter publie des cookbooks pour filtrer les appels d'outils d'agent avec Jev et pour approuver automatiquement les invites de permission des agents de codage (Claude Code, Codex, Cursor, OpenCode) avec une vérification de réversibilité.

Le modèle : avant d'exécuter chaque appel d'outil, envoyez l'appel en attente plus l'état minimum dont la question a besoin, et posez, par exemple, une question noul « Cet appel est-il réversible ? » et une question score pour savoir à quel point il correspond à la demande de l'utilisateur. Exécutez automatiquement sur un oui avec un score élevé ; sinon, faites remonter au palier phare ou à une personne.

Coût sur l'exécution de référence, en supposant 500 tokens d'état par vérification et une vérification par étape : 12 × 500 = 6 000 tokens en entrée × $0.042 par million = $0.00025 par exécution, environ 1,4 % d'une exécution GPT-6 Luna. La latence est le coût le plus important : à une médiane d'environ 0,24 seconde, 12 vérifications séquentielles ajoutent environ 3 secondes par exécution.

Jev lit les instructions littéralement, donc gardez l'arithmétique, les comparaisons de budget et les vérifications de date dans votre propre code. Il ne renvoie aucune explication, donc enregistrez vous-même l'appel en attente et la réponse typée de Jev.

Modèle le moins cher en dehors du niveau D qui exécute un agent : Claude Haiku 5.5 ou GPT-6 Luna à $0,0185 par exécution en 12 étapes, derrière un validateur ; DeepSeek V4.1 Flash est à $0,027 en heures creuses et $0,054 en heures pleines. Le moins cher que nous exécuterions sans supervision avec des schémas stricts : Gemini 3.8 Flash ou GPT-5.4 mini à environ $0,14. Sur Anthropic, essayez Haiku 5.5 derrière un validateur avant de payer dix fois plus pour l'ancien Haiku 4.5. Qui devrait payer les tarifs phares à chaque étape : les équipes dont les appels d'outils ont des effets secondaires ou dont les échecs coûtent du temps réel. Qui ne devrait pas : quiconque dispose d'un validateur et d'un mélange de tâches routinières. Le moyen le moins cher d'obtenir le résultat : mise en cache d'abord, niveau B par défaut, une tentative de niveau C derrière un validateur, et un budget partagé par exécution.