GPT-6 Luna face à GPT-5.6 Luna : calculer le coût réel d’une tâche acceptée dans Codex

Votre vraie décision dans Codex n’est pas de savoir quelle génération Luna paraît la plus récente, mais laquelle doit traiter le prochain lot de tâches et quand changer après un échec. À la fin, vous pourrez choisir un premier candidat selon le coût par tentative, puis calculer le coût réel d’une tâche acceptée avec taux d’acceptation, reprises et temps de correction manuelle.

Commencez ici : testez d’abord gpt-6-luna pour la plupart des tâches vérifiables automatiquement

gpt-6-luna est le meilleur premier candidat lorsque le périmètre est clair et que les tests, le lint ou un script d’acceptation peuvent rejeter rapidement un mauvais résultat. Son coût inférieur par tentative permet d’établir une base à moindre coût, puis de décider si le travail complexe doit revenir à gpt-5.6-luna.

Votre situation	Première action	Ce qui changerait le conseil
Petites corrections ou changements en série avec tests automatisés	Commencez par gpt-6-luna	Les échecs se répètent ou la correction manuelle annule l’avantage tarifaire
Fonctionnalité multi-fichiers, refactorisation ou changement d’interface	Exécutez un test apparié des deux modèles	Confiez cette classe à gpt-5.6-luna si elle réduit nettement les reprises et corrections
L’entrée approche ou dépasse 272K	Retirez les fichiers inutiles, raccourcissez l’historique ou divisez la tâche	Si le contexte ne peut pas être réduit, comparez les tarifs de contexte long
Vous utilisez les quotas d’un forfait ChatGPT ou Codex	Consultez le tableau de bord du forfait et les règles de Credit, pas le tableau API	Appliquez les tarifs par token après passage à une API Key ou un custom provider

Les informations publiques ne donnent pas encore de résultats appariés avec la même version de Codex, le même dépôt et le même reasoning effort. Le prix peut déterminer l’ordre du test, mais vos propres tâches doivent déterminer le modèle par défaut.

Les limites d’interface sont proches et ne prédisent pas la qualité du code

Les deux modèles ont des interfaces principales et des limites de contexte proches ; la fiche technique ne permet donc pas de savoir lequel sera le plus fiable dans votre code. Tous deux acceptent texte et image, produisent du texte, prennent en charge Responses API, reasoning tokens et reasoning effort de none à max, avec 1,050,000 tokens de contexte, 922,000 tokens d’entrée au maximum et 128,000 de sortie.

Élément	gpt-6-luna	gpt-5.6-luna
Positionnement officiel	Modèle efficace pour des tâches ciblées à grand volume	Modèle pour des charges à grand volume sensibles au coût
Date de fin des connaissances	2026-05-18	2026-02-16
Fenêtre de contexte	1,050,000 tokens	1,050,000 tokens
Reasoning effort par défaut	medium	medium

Ces caractéristiques ne prouvent pas qu’un modèle aura un meilleur taux d’acceptation, finira plus vite ou demandera moins de reprises dans votre code. Le résultat de Codex dépend aussi de la forme de la tâche, de la qualité du contexte, des autorisations d’outils, de la version du client, du reasoning effort et des critères d’acceptation.

Jusqu’à 272K, gpt-6-luna a les tarifs par token les plus bas

Avec un contexte d’entrée complet inférieur ou égal à 272K, gpt-6-luna coûte deux fois moins cher en entrée, lecture et écriture du cache, et sa sortie coûte environ 41.7% de celle de gpt-5.6-luna. Le tableau a été vérifié le 2026-09-25, utilise des USD par million de tokens et compare uniquement OpenAI Standard à la facturation API de BetterToken, sans quotas de forfait ChatGPT/Codex ni facturation en Credit.

Jusqu’à 272K : calculez directement avec ce tableau

Utilisez directement ce palier lorsque le contexte d’entrée complet de chaque requête reste à 272K ou moins, sans appliquer les multiplicateurs de contexte long.

Model ID	Fournisseur	Entrée	Lecture du cache	Écriture du cache	Sortie
gpt-6-luna	OpenAI Standard	$0.10	$0.01	$0.125	$0.50
gpt-6-luna	BetterToken	$0.068	$0.0068	$0.085	$0.34
gpt-5.6-luna	OpenAI Standard	$0.20	$0.02	$0.25	$1.20
gpt-5.6-luna	BetterToken	$0.136	$0.0136	$0.17	$0.816

Les prix BetterToken sont dynamiques : il faut consulter les prix actuels le jour de la publication ou de l’achat et utiliser les valeurs alors affichées. BetterToken n’est pas un produit OpenAI. Les tarifs ci-dessus concernent son groupe GPT utilisable via API, Codex et les outils acceptant une Base URL personnalisée ; ils ne correspondent pas à des quotas d’abonnement ChatGPT ou Codex.

Pour ces modèles, OpenAI Batch et Flex coûtent 50% de Standard et sont donc moins chers que les tarifs BetterToken affichés ici. Ils sont exclus de cette comparaison. Le tableau ne signifie pas que BetterToken est moins cher que tous les modes de traitement OpenAI.

Au-dessus de 272K : réduisez d’abord l’entrée, puis utilisez les tarifs longs

Si la tâche peut être divisée, retirez les fichiers inutiles, raccourcissez l’historique ou séparez le travail avant le seuil, car toute la requête devient plus chère. Le seuil porte sur le contexte d’entrée complet, parties en cache comprises ; au-dessus de 272K, entrée, lecture et écriture du cache coûtent 2 fois le tarif court, et la sortie 1.5 fois :

Model ID	Fournisseur	Entrée	Lecture du cache	Écriture du cache	Sortie
gpt-6-luna	OpenAI Standard	$0.20	$0.02	$0.25	$0.75
gpt-6-luna	BetterToken	$0.136	$0.0136	$0.17	$0.51
gpt-5.6-luna	OpenAI Standard	$0.40	$0.04	$0.50	$1.80
gpt-5.6-luna	BetterToken	$0.272	$0.0272	$0.34	$1.224

Séparez quatre catégories de tokens pour reproduire le coût d’une tentative

Pour calculer une tentative Codex, séparez entrée non mise en cache, lecture du cache, écriture du cache et sortie. Le profil hypothétique commun ci-dessous montre la méthode ; remplacez ces chiffres par votre facturation pour obtenir votre coût réel par tentative :

• 32,000 tokens d’entrée non mis en cache ;
• 160,000 tokens lus dans le cache ;
• 16,000 tokens écrits dans le cache ;
• 8,000 tokens de sortie ;
• un contexte d’entrée complet inférieur ou égal à 272K pour chaque requête, donc les tarifs de contexte court.

La formule est :

Coût de la tâche = entrée non mise en cache / 1,000,000 × prix d’entrée
                  + lecture du cache / 1,000,000 × prix de lecture
                  + écriture du cache / 1,000,000 × prix d’écriture
                  + sortie / 1,000,000 × prix de sortie

Model ID	Fournisseur	Coût d’entrée	Coût de lecture du cache	Coût d’écriture du cache	Coût de sortie	Total par tentative
gpt-6-luna	OpenAI Standard	$0.003200	$0.001600	$0.002000	$0.004000	$0.010800
gpt-6-luna	BetterToken	$0.002176	$0.001088	$0.001360	$0.002720	$0.007344
gpt-5.6-luna	OpenAI Standard	$0.006400	$0.003200	$0.004000	$0.009600	$0.023200
gpt-5.6-luna	BetterToken	$0.004352	$0.002176	$0.002720	$0.006528	$0.015776

Avec ce profil hypothétique, une tentative gpt-6-luna coûte environ 46.6% d’une tentative gpt-5.6-luna. BetterToken applique le même multiplicateur tarifaire aux deux modèles ; le rapport entre modèles est donc identique chez les deux fournisseurs. Cela reste un coût par tentative, pas un coût par tâche réussie.

Comptez la lecture du cache à part pour éviter de surestimer ou sous-estimer le coût

Ne facturez pas la lecture du cache comme une entrée ordinaire et ne l’omettez pas. Codex relit le contexte du dépôt, l’historique et les résultats d’outils ; les tokens en cache sont généralement moins chers, mais peuvent être nombreux, donc une seule valeur « entrée » fausse le calcul.

Pour chaque exécution, conservez séparément input, cached input, cache write et output. Si une couche d’accès n’affiche qu’un montant final sans les quatre catégories de tokens, il devient bien plus difficile d’expliquer pourquoi un modèle ou une tâche coûte davantage.

Choisissez le modèle par défaut selon le coût par tâche acceptée

Un appel peu cher ne garantit pas une tâche terminée à faible coût ; incluez les coûts API des échecs, retours en arrière et nouvelles tentatives. La mesure la plus utile est :

Coût par tâche acceptée = coût API total de toutes les tentatives / tâches acceptées

Consignez au minimum :

• Taux d’acceptation : part des tâches qui passent les critères prédéfinis sans réécriture de la solution par un développeur ;
• Nouvelles tentatives : nouveaux prompts, retours en arrière ou nouvelles exécutions du modèle pour la même tâche ;
• Durée totale : du début jusqu’à un diff acceptable, et non la seule latence du premier token ;
• Correction manuelle : nécessité et durée des modifications du code généré ;
• Profil de tokens : entrée non mise en cache, lectures du cache, écritures du cache et sortie.

Avec les coûts hypothétiques OpenAI Standard ci-dessus, le rapport par tentative est 0.010800 / 0.023200 ≈ 46.6%. Si le profil de tokens restait identique, gpt-6-luna conserverait un coût API attendu inférieur tant que son taux d’acceptation dépasserait environ 46.6% de celui de gpt-5.6-luna. Il s’agit uniquement d’un point d’équilibre dérivé de prix hypothétiques, pas d’une conclusion mesurée sur la qualité. Le seuil change lorsque les tokens, les reprises ou la répartition des tâches changent.

Fixez cinq conditions avant de faire confiance à la comparaison

Une seule exécution de chaque modèle ne constitue pas une comparaison valide ; ils doivent partir du même état, recevoir des tâches comparables et suivre les mêmes critères d’acceptation. Ces cinq étapes réduisent les biais liés au cache, à l’ordre et au jugement humain.

1. Figer l’environnement

Utilisez la même version de Codex, le même commit Git initial, la même configuration, les mêmes autorisations d’outils, le même reasoning effort, le même prompt et la même commande d’acceptation pour les deux modèles. N’appelez pas un modèle via OpenAI Standard et l’autre par un chemin différent avant d’attribuer toutes les différences de latence ou d’échec au modèle.

2. Séparer les catégories de tâches

Conservez au minimum trois classes distinctes :

Classe de tâche	Exemple	Critère d’acceptation suggéré
Petite correction	Défaut bien défini dans un ou quelques fichiers	Les tests ciblés passent ; les fichiers sans rapport restent inchangés
Modification multi-fichiers	Fonctionnalité, refactorisation ou changement coordonné d’interfaces	Tous les tests et le lint passent ; le comportement demandé est présent
Revue et diagnostic	Trouver un bug, expliquer le risque, proposer une correction	Le problème connu est trouvé avec des preuves concrètes dans le code

Ne fusionnez pas les trois dans une moyenne unique. Deux modèles peuvent être presque équivalents sur les petites corrections, mais différer nettement en taux de reprise sur les modifications multi-fichiers.

3. Définir l’acceptation avant l’exécution

Fixez à l’avance les tests obligatoires, les répertoires autorisés, la politique de dépendances et les conditions d’échec. Abaisser le niveau après avoir vu une sortie rend le taux d’acceptation dépourvu de sens.

4. Alterner l’ordre des modèles

N’exécutez pas toujours le même modèle en premier. Alternez l’ordre ou utilisez, lorsque c’est possible, des tâches indépendantes équivalentes afin que le cache du premier passage, la réparation de l’environnement et l’expérience de l’opérateur ne favorisent pas systématiquement un modèle.

5. Conserver les données de chaque tâche

Une ligne utile contient : ID de tâche, classe, Model ID, fournisseur, niveau de traitement, reasoning effort, heure de début et de fin, quatre catégories de tokens, nombre de tentatives, résultat, motif d’échec, minutes de correction manuelle et coût final. Conservez les lignes brutes avant d’agréger par classe.

Quand conserver gpt-6-luna et quand passer à gpt-5.6-luna

Conservez gpt-6-luna comme candidat par défaut tant que son taux d’acceptation préserve l’avantage tarifaire et que le temps de correction manuelle reste comparable. Si les résultats changent selon la classe de tâche, routez le travail au lieu d’imposer un modèle global.

Ce que vous observez	Action recommandée
L’acceptation de gpt-6-luna dépasse environ 46.6% de celle de gpt-5.6-luna, avec profils de tokens et correction proches	Conservez gpt-6-luna ; le coût API attendu est inférieur
gpt-6-luna passe sous le seuil de rentabilité, ou reprises et corrections rendent le total plus élevé	Passez cette classe de tâches à gpt-5.6-luna
gpt-6-luna gagne sur les petites corrections, mais gpt-5.6-luna réduit les reprises multi-fichiers	Routez par classe de tâche au lieu de choisir un défaut universel
La différence vient surtout de latence, erreurs ou limites du fournisseur	Recommencez par le même chemin d’accès avant de l’attribuer au modèle
L’entrée dépasse souvent 272K	Optimisez le contexte et retestez ; ne confondez pas changement de tarif et qualité

Le seuil de 46.6% ne vaut que pour le profil hypothétique ci-dessus. Si longueur de sortie, cache ou nombre de reprises changent, recalculez le point d’équilibre avec le coût réel par tentative de chaque modèle.

Recommandation : établissez la base avec gpt-6-luna, puis décidez par coût de réussite

Si vous devez choisir aujourd’hui, commencez les tâches claires et vérifiables automatiquement avec gpt-6-luna. Gardez un échantillon représentatif de tâches complexes pour exécuter gpt-5.6-luna dans les mêmes conditions ; ne vous arrêtez pas au prix d’un appel.

Après un lot de tâches comparables, calculez taux d’acceptation, reprises moyennes, temps de correction manuelle et coût par tâche acceptée. Conservez gpt-6-luna par défaut s’il reste moins cher ; si gpt-5.6-luna évite assez de reprise pour couvrir son tarif supérieur sur une classe, routez uniquement cette classe vers lui.

Références officielles

Utilisez ces trois pages officielles pour revérifier les spécifications et les prix OpenAI.

• Page du modèle GPT-6 Luna
• Page du modèle GPT-5.6 Luna
• Tarifs de l’API OpenAI