Gemini 4 Argon vs GPT-6 Astra : test, vitesse et prix de l'API

Le 23 octobre 2026, nous avons confié à Gemini 4 Argon et à GPT-6 Astra les mêmes trois tâches : corriger un bug de facturation, répondre à des questions sur un journal de 306 lignes et transformer un fil d'e-mails en JSON. Argon a donné toutes les bonnes réponses. Astra a été plus rapide sur deux tâches, mais a coûté 3,4 à 4,9 fois plus cher par tâche et s'est trompé deux fois sur le nombre d'erreurs du journal.

Les deux modèles sont disponibles dans l'API. Le prix de lancement d'Argon s'arrête le 30 novembre. À partir du 1er décembre, il double, et Astra coûtera toujours environ deux fois plus cher par tâche.

Les prix catalogue sont par million de tokens, et ceux d'Argon sont des prix de lancement jusqu'au 30 novembre. Les deux sont sur OmniaKey : Gemini 4 Argon et GPT-6 Astra.

Peut-on utiliser Gemini 4 Argon et GPT-6 Astra aujourd'hui ?

Oui. Argon est disponible dans l'API Gemini payante depuis le 13 octobre 2026, et Astra dans l'API OpenAI depuis le 3 septembre.

Certaines pages de la semaine de lancement affirment encore qu'Argon est inaccessible. Quand Google l'a annoncé le 30 septembre, l'accès était réservé aux défenseurs informatiques de confiance du programme Fairwind. Cela a changé le 13 octobre.

Aucun des deux n'est dans l'offre gratuite de son fournisseur. Argon arrive aussi chez les abonnés Google AI Ultra et Pro dans l'application Gemini.

La fenêtre d'Argon est partagée entre l'entrée, le raisonnement et la sortie, et son mode « long decode » porte la sortie jusqu'à 1 048 576 tokens. Argon accepte le texte, les images, la vidéo, l'audio et le PDF. Astra accepte le texte et les images.

Les niveaux de raisonnement d'Astra sont low, medium, high, xhigh et max, sans « none ». Chez OpenAI, les appels d'outils passent par l'API Responses.

Avec OmniaKey, vous appelez les deux avec une seule clé sur https://api.omniakey.com/v1, avec les ID ci-dessus. Les tarifs sont sur la page Gemini 4 Argon et sur la page GPT-6 Astra.

Notre méthode de test

• Modèles : Gemini 4 Argon (gemini-4-argon) et GPT-6 Astra (gpt-6-astra).
• Le 23 octobre 2026, via l'API Chat Completions compatible OpenAI d'OmniaKey, en streaming et sans réglage de raisonnement, donc chaque modèle a utilisé sa valeur par défaut. Google documente medium comme niveau de réflexion par défaut d'Argon.
• Le même prompt pour les deux modèles. La correction du bug et la tâche du journal ont tourné deux fois par modèle, la tâche JSON une fois : 10 réponses au total.
• Le temps va de l'envoi de la requête au dernier token, mesuré de notre côté, réseau compris.
• Notation par scripts, pas au goût. Chaque correction a tourné contre 12 tests que les modèles n'ont jamais vus, dans un processus Python isolé. Les réponses du journal ont été comparées à la clé du script qui a généré le journal, et le JSON champ par champ à sa propre clé. La seule question ouverte, la cause probable du journal, a été jugée à la lecture.
• Coût : les tokens de notre prompt et de la réponse, multipliés par le prix catalogue standard de chaque fournisseur, au premier passage (rien en cache).
• OmniaKey vend l'accès API aux deux modèles, donc les tests sont passés par OmniaKey. Chaque prix ici est celui de Google ou d'OpenAI, pas le nôtre.
• Les prix, limites et dates viennent des pages de Google et d'OpenAI listées dans Sources, vérifiées le 23 octobre 2026.

Cela fait un ou deux passages par tâche : lisez donc les résultats comme des exemples du comportement de chaque modèle, pas comme un benchmark.

Que se passe-t-il avec les trois mêmes tâches ?

Les deux ont corrigé le bug et rempli le JSON correctement. Le journal long les a séparés, et Astra a été plus rapide sur deux des trois tâches.

Test 1 : corriger un bug de facturation en Python

Le modèle corrige-t-il toutes les règles cassées d'un petit fichier, et pas seulement les trois tests qui échouent ?

Prompt :

You're fixing a bug report in our billing service. Below are billing.py, its test file and the test output. Three tests fail.

Fix billing.py so it follows every rule in its docstring, not only the failing tests. Keep the function names and signatures, and use only the Python standard library.

Reply with the complete corrected billing.py in one ```python code block, then at most three short bullets on what you changed.

En dessous, nous avons collé le fichier billing.py de 34 lignes, ses quatre tests et la sortie : 3 échecs, 1 réussite. Le fichier avait quatre bugs.

1. round() arrondit au pair le plus proche là où les règles demandent un arrondi au supérieur.
2. Les remises sur volume commençaient à 11 et 51 unités au lieu de 10 et 50.
3. Le code promo s'appliquait après la taxe.
4. Aucun contrôle ne vérifiait que le code promo est entre 0 et 100.

Nous avons noté chaque correction avec 12 tests que les modèles n'ont jamais vus.

• Gemini 4 Argon (10,8 s, 10,6 s) : les deux corrections passent 12 tests sur 12. Toutes deux utilisent le module decimal de Python avec un arrondi au supérieur. La première emploie une annotation de type (float | Decimal) qui exige Python 3.10 ou plus récent.
• GPT-6 Astra (17,3 s, 6,4 s) : les deux corrections passent 12 tests sur 12. La première utilise des fractions exactes et c'est la seule réponse d'Astra à déclarer des tokens de raisonnement (185). C'est aussi la réponse la plus lente de ce test.

Après la notation, nous avons essayé trois cas limites de plus sur les quatre corrections. La deuxième d'Astra se trompe d'un centime sur deux d'entre eux : elle arrondit le prix après le code promo au lieu du code promo lui-même. Un code de 50 % sur une commande de 1 001 centimes retire donc 500 centimes, pas 501.

Verdict : égalité sur nos tests. Les deux modèles ont corrigé les quatre bugs. Les deux réponses d'Argon passent aussi tous les cas supplémentaires, et chacune coûte moins d'un centime contre 3 à 5 centimes chez Astra.

Test 2 : trouver la cause dans un journal de 306 lignes

Le modèle sait-il compter, chercher et raisonner sur un long texte sans se tromper ?

Prompt :

Below is a 20-minute slice of our API gateway's access log. Answer five questions using only this log.

Q1. When did the first 503 happen? Give the timestamp, the request ID and the upstream.

Q2. How many requests returned 503 in total, and which upstream or upstreams served them?

Q3. Which request was the slowest? Give its request ID, path and rt_ms.

Q4. List every request made by user u_4471, in order, as time method path status.

Q5. In one or two sentences: what most likely caused the 503s, and what would you check first?

Start each answer with Q1: to Q5:. No preamble.

Sous les questions, nous avons collé 306 lignes (43 Ko) d'un journal de passerelle inventé couvrant 20 minutes. Il contenait des pièges : un ID utilisateur avec deux chiffres inversés (u_4417), un scanner qui frappe des pages absentes et une recherche lente (9 214 ms) juste derrière la requête la plus lente (9 871 ms). Un script a généré le journal et la clé de réponses.

• Gemini 4 Argon (9,5 s, 10,0 s) : 5 sur 5 aux deux passages, y compris le total de 14 erreurs, toutes venues de payments-1. Sa cause : ce service amont échouait vite (2 à 9 ms, réponses identiques de 162 octets) de 14:07:12 à 14:09:55, tandis que payments-2 restait sain.
• GPT-6 Astra (5,7 s, 5,4 s) : 4 sur 5 aux deux passages. Il a compté 16 erreurs, puis 15. Il y en avait 14. Tout le reste était juste, y compris la même cause.

Verdict : Argon. Un compte faux dans un journal est le genre d'erreur qu'on ne voit qu'en vérifiant, et Astra l'a commise aux deux passages. Astra a répondu en environ la moitié du temps.

Si vous utilisez l'un ou l'autre sur des journaux, demandez les lignes correspondantes avec chaque total, vous vérifierez le chiffre en quelques secondes.

Test 3 : transformer un fil d'e-mails en JSON

Le modèle extrait-il des champs exacts d'un texte désordonné en respectant un format strict ?

Prompt :

Turn this support email thread into one JSON object for our ticketing system.

Schema (every key is required):

• "order_id": string
• "customer_email": string, the From address of the customer's most recent message
• "items": array of objects with "sku" (string) and "quantity" (integer), only the items in the customer's latest request
• "requested_action": one of "refund", "replacement", "other"
• "refund_amount_cents": integer, or null if no refund is requested
• "deadline": "YYYY-MM-DD", or null if none is given; resolve relative dates against the Date header of the message they appear in
• "escalation_risk": boolean, true if the customer threatens a chargeback, a bank dispute or legal action

If the customer changed their mind, use the latest request. Return only the JSON object: no code fences, no comments, no extra keys.

Le fil contenait deux e-mails de la même personne. Lundi, depuis une adresse professionnelle, elle demandait deux lampes de remplacement.

Mercredi, depuis une adresse personnelle, elle a changé d'avis : remboursement de deux lampes et d'un chargeur, 157,50 $ en tout, avant « vendredi », sinon elle contesterait le paiement auprès de sa banque. Le fil mentionne aussi une ancienne commande sans problème.

• Gemini 4 Argon (6,8 s) : les sept champs justes, dans un JSON valide et sans rien de plus : un remboursement de 15 750 centimes, l'adresse personnelle, les deux articles et « vendredi » résolu au 2026-10-16.
• GPT-6 Astra (3,9 s) : la même chose, champ par champ.

Verdict : égalité sur l'exactitude. Astra a répondu en environ la moitié du temps. Argon a coûté 0,003 $ contre 0,013 $.

Côté vitesse, Astra commence à répondre plus tôt. Son premier token arrive en 3,1 à 3,8 secondes sur toutes les réponses sauf celle qui a raisonné (9,4 s). Celui d'Argon met 5,1 à 6,8 secondes, même sur le prompt JSON court, et il déclare 0 token de réflexion sur les cinq réponses.

Si les réponses doivent démarrer vite, Astra garde l'avantage. Si un total ou une recherche doit être juste, Argon a mieux fait ici.

Que disent les benchmarks publiés ?

Dans le tableau de Google, Argon mène six lignes sur dix et Astra trois, avec une égalité. Artificial Analysis, un site de benchmarks indépendant, les note à égalité.

Ce sont les chiffres de Google, tirés de la fiche du modèle Gemini 4 Argon, avec des résultats d'octobre 2026.

Les victoires d'Astra sont les lignes d'agents : FrontierSWE v2 (65,5 % contre 55,0 %), Terminal-bench 4.0 et OSWorld-2.0, qui testent le code dans un terminal et l'usage d'un ordinateur. Les plus gros écarts d'Argon sont dans le travail de connaissance : le test d'agents juridiques de Harvey (19,6 % contre 5,4 %), AutomationBench et le Vals Index.

Artificial Analysis donne 53 aux deux sur son Intelligence Index, mais a fait tourner Argon en raisonnement élevé et Astra en max. À ces réglages, Argon a écrit environ deux fois plus de tokens de sortie par tâche (36k contre 17k) et a quand même coûté moins cher par tâche (1,99 $ contre 3,26 $). Le site mesure aussi Argon plus rapide en génération une fois lancé : 82 contre 56 tokens par seconde.

OpenAI annonce 98 % sur FrontierMath Tier 4 et 99,9 % sur ARC-AGI-3 pour Astra. Le tableau de Google n'inclut pas ces tests, donc il n'y a pas de chiffre Argon à mettre en face.

Pour les agents de terminal et l'usage d'un ordinateur, même les chiffres de Google favorisent Astra. Pour le travail de connaissance très documentaire, ils favorisent Argon.

Combien coûte une tâche chez chacun ?

Aux prix catalogue, Astra a coûté 3,4 à 4,9 fois plus cher par tâche qu'Argon dans nos passages. Quand le prix d'Argon doublera le 1er décembre, Astra coûtera encore 1,7 à 2,4 fois plus cher.

Ces prix viennent de la page tarifaire de l'API Gemini de Google et de la page du modèle GPT-6 Astra d'OpenAI, vérifiées le 23 octobre 2026.

Batch et Flex coûtent moitié prix chez les deux. Chez Astra, les prompts de plus de 272K tokens d'entrée coûtent 2x en entrée et en cache et 1,5x en sortie sur toute la requête. La page tarifaire de Google ne mentionne aucun supplément pour les prompts longs chez Argon.

Pour fixer les idées : 1 000 tâches de journal comme les nôtres reviennent à environ 60 $ sur Argon jusqu'au 30 novembre, environ 120 $ à partir du 1er décembre, et environ 205 $ sur Astra.

L'écart est plus petit que le facteur 5 des prix catalogue, pour deux raisons. Argon a écrit des réponses plus longues (401 contre 218 tokens de sortie sur la tâche journal), et Google a compté le même journal de 43 Ko comme plus de tokens d'entrée qu'OpenAI.

Posez la même question sur le même journal deux minutes plus tard et les deux facturent l'essentiel au tarif du cache. Notre deuxième passage sur le journal a coûté environ 0,011 $ sur Argon et environ 0,033 $ sur Astra, soit environ 80 % de moins que le premier.

Une règle d'OpenAI à connaître : sur les modèles GPT-6, le mode de cache par défaut facture les tokens de prompt écrits dans le cache à 1,25 fois le tarif d'entrée. Le premier appel sur le journal peut donc coûter environ 0,25 $ au lieu de 0,205 $.

Lequel choisir ?

Prenez Argon pour les documents longs, les journaux et le volume. Prenez Astra quand les réponses doivent démarrer vite ou quand vos agents travaillent dans un terminal ou sur un ordinateur.

Le 1er décembre, le prix d'Argon double à 4 $ et 20 $ par million de tokens, soit encore 40 % du prix catalogue d'Astra, donc le choix ci-dessus tient. Mélanger les deux est simple, car ils tournent sur la même API avec une seule clé.

Une répartition simple : Argon là où un chiffre faux coûte cher, Astra là où une réponse lente coûte cher. Commencez par Gemini 4 Argon sur OmniaKey et GPT-6 Astra sur OmniaKey.

Comment lancer le même test avec une seule clé d'API ?

Utilisez le SDK Python d'OpenAI pointé vers OmniaKey et changez une chaîne pour passer d'un modèle à l'autre. Nous avons exécuté ce code le 23 octobre 2026.

import os
import time

from openai import OpenAI

client = OpenAI(
    base_url="https://api.omniakey.com/v1",
    api_key=os.environ["OMNIAKEY_API_KEY"],
)

model = "gemini-4-argon"  # change to "gpt-6-astra" to compare
prompt = open("ticket-prompt.md").read()  # the support-ticket task from Test 3

start = time.perf_counter()
response = client.chat.completions.create(
    model=model,
    messages=[{"role": "user", "content": prompt}],
)
print(response.choices[0].message.content)
print(f"{time.perf_counter() - start:.1f} s", response.usage)

1. Créez une clé sur OmniaKey et définissez-la dans OMNIAKEY_API_KEY.
2. Installez le SDK : pip install openai.
3. Enregistrez votre prompt dans ticket-prompt.md, par exemple les instructions du test 3 suivies d'un de vos fils d'e-mails.
4. Lancez le script. Il affiche la réponse, le temps et les tokens utilisés.
5. Passez model à "gpt-6-astra" et relancez.

Quand nous avons lancé ce script sur Argon avec le prompt du test 3, il a renvoyé le bon JSON en 7,1 secondes, avec 634 tokens d'entrée et 152 de sortie.

Questions fréquentes

Gemini 4 Argon est-il meilleur que GPT-6 Astra ?

Sur nos trois tâches, Argon a toujours eu juste et a coûté moins cher, et Astra a été plus rapide sur deux. Le tableau de Google place Argon en tête sur six lignes sur dix, et Artificial Analysis les note à égalité, à 53.

Gemini 4 Argon est-il disponible pour tout le monde ?

Il est dans l'API Gemini payante depuis le 13 octobre 2026, mais pas dans l'offre gratuite. Les abonnés Google AI Ultra et Pro y ont aussi accès dans l'application Gemini.

Combien Gemini 4 Argon coûte-t-il de moins que GPT-6 Astra ?

Jusqu'au 30 novembre, son prix catalogue est le cinquième de celui d'Astra : 2 $ et 10 $ contre 10 $ et 50 $ par million de tokens. Sur nos tâches, Astra a coûté 3,4 à 4,9 fois plus cher. À partir du 1er décembre, le prix catalogue d'Argon est 40 % de celui d'Astra (4 $ et 20 $ contre 10 $ et 50 $).

Lequel est meilleur pour coder ?

Les deux ont corrigé notre bug et passé les 12 tests cachés. Dans le tableau de Google, Argon mène DeepSWE v1.1 (77,9 % contre 74,1 %), tandis qu'Astra mène FrontierSWE v2 (65,5 % contre 55,0 %) et Terminal-bench 4.0 (58,2 % contre 57,4 %).

Gemini 4 Argon réfléchit-il par défaut ?

Oui, en medium. Il a déclaré 0 token de réflexion sur nos trois tâches, mais en a dépensé 471 sur un casse-tête de comptage plus dur et l'a résolu : il réfléchit quand la tâche le demande.

Sources

• Google : annonce de Gemini 4 Argon (30 septembre 2026), billet sur la disponibilité générale (13 octobre 2026), journal des changements de l'API Gemini, page du modèle, tarifs, niveaux de réflexion, fiche du modèle
• OpenAI : annonce de GPT-6 Astra, page du modèle, tarifs, cache de prompts, journal des changements
• Artificial Analysis : page de comparaison

Tout vérifié le 23 octobre 2026.

Journal des mises à jour

• 23 octobre 2026 : première publication. Tests exécutés le 23 octobre via l'API OmniaKey.