Gemini 4 Argon, 1M tokens de sortie : L'impact d'une réponse d'un million de tokens sur votre stack API

Le chiffre phare de Gemini 4 Argon, 1 million de jetons, représente sa limite de sortie, et non sa fenêtre de contexte. Google affirme qu'une seule réponse d'Argon peut atteindre 1 million de jetons, soit environ 16 fois la limite précédente de 64 000 jetons, et n'a pas du tout publié la fenêtre d'entrée d'Argon. Il n'y a rien à appeler pour l'instant : Argon n'est actuellement disponible que pour les participants au programme Fairwind, les clients payants de l'API suivront une fois que Google aura ouvert l'accès (voir le guide d'accès et de la date de sortie).

Une réponse aussi longue brise trois hypothèses sur lesquelles la plupart des piles d'API reposent : un appel se termine en quelques secondes, le corps tient en mémoire, et une requête a un coût faible et prévisible. Ce guide couvre le coût d'une réponse maximale, le streaming, les délais d'attente, les plafonds de sortie, le stockage, et comment tester tout cela dans Apidog avant l'ouverture de l'accès. Pour un aperçu du modèle, voir ce qu'est Gemini 4 Argon ; pour les formats de requêtes, voir le guide de l'API Gemini 4 Argon.

1 million de jetons de sortie n'est pas une fenêtre de contexte de 1 million de jetons

Plusieurs pages classées pour Argon décrivent le chiffre de 1 million comme une fenêtre de contexte, et un titre l'appelle une « fenêtre de contexte 16 fois plus grande ». C'est l'inverse. Le billet de lancement de Google indique qu'il a étendu « la limite de jetons de sortie du modèle à 1 million de jetons, un chiffre de pointe dans l'industrie ». Ce 64K correspond au plafond de sortie de 65 536 jetons sur Gemini 3.1 Pro Preview, le précédent modèle Pro haut de gamme de Google.

L'entrée est un nombre distinct que Google n'a pas communiqué. Son évaluation de contexte long, décrite dans la méthodologie d'évaluation, a utilisé des invites entre 256K et 1M de jetons. Il s'agit d'un sous-ensemble de benchmark, pas d'une spécification. Il y a aussi une mise en garde concernant la sortie : Vals AI indique une sortie maximale de 262K pour la configuration Argon qu'il a testée. Google affirme que la limite du modèle est de 1 million ; au moins un évaluateur tiers a constaté une limite inférieure sur le point de terminaison qu'il a utilisé.

Chaque concurrent plafonne la sortie synchrone à 128K, donc la limite déclarée d'Argon est environ 8 fois supérieure. La raison de Google est la profondeur du raisonnement : avec une marge de manœuvre, le modèle peut « générer des centaines de milliers de jetons en une seule trajectoire » et résoudre des problèmes difficiles en une seule passe. Pour savoir comment d'autres fournisseurs gèrent les exécutions longues, voir les tâches de 18 heures de Claude Opus 5.5 et le guide de l'API GPT-6 Astra.

Ce que coûte une réponse maximale

Évaluez d'abord le plafond. La sortie est facturée 10 $ par million de jetons pendant la période de lancement d'Argon et 20 $ après, donc une réponse complète coûte :

• Introduction : 1 000 000 x 10 $/1M = 10,00 $ de sortie
• Standard : 1 000 000 x 20 $/1M = 20,00 $ de sortie

L'entrée s'ajoute à cela. Une invite de 200 000 jetons ajoute 200 000 x 2 $/1M = 0,40 $ aux tarifs d'introduction ou 0,80 $ au tarif standard, donc un seul appel maximal coûte 10,40 $ ou 20,80 $. Une tâche nocturne qui en déclenche 100 coûte 1 040 $ aux tarifs d'introduction.

La réflexion rend cela plus difficile à voir. Sur les modèles Gemini actuels, les jetons de réflexion sont facturés comme de la sortie ; Google n'a pas précisé si Argon suit cette règle ou si la réflexion compte pour le plafond de 1 million. Dans tous les cas, une réponse visible courte peut toujours entraîner une facture de sortie importante. Le guide de tarification de Gemini 4 Argon présente d'autres scénarios, y compris l'entrée en cache avec 95 % de réduction.

Pourquoi le streaming est obligatoire

Un appel sans streaming ne renvoie rien tant que la réponse complète n'est pas terminée. Avec des centaines de milliers de jetons, c'est une longue connexion silencieuse, et les délais d'attente d'inactivité dans votre pile peuvent la fermer avant l'arrivée du premier octet.

Diffusez plutôt. Sur generateContent, remplacez la méthode par :streamGenerateContent?alt=sse et Google envoie des événements envoyés par le serveur, un morceau de candidats partiels par événement. Lisez chaque événement au fur et à mesure qu'il arrive et écrivez-le ; ne collectez pas le corps en premier. Cela fonctionne sur Gemini 3.8 Flash aujourd'hui, avec le modèle dans une variable car Google n'a pas publié l'ID du modèle d'Argon (la configuration est dans notre guide de l'API Gemini 3.8 Flash) :

import json, os, requests

MODEL = os.environ.get("GEMINI_MODEL", "gemini-3.8-flash")
URL = ("https://generativelanguage.googleapis.com/v1beta/models/"
       f"{MODEL}:streamGenerateContent?alt=sse")
body = {
    "contents": [{"parts": [{"text": "Write a test plan for every endpoint in a payments API."}]}],
    "generationConfig": {"maxOutputTokens": 60000},
}
usage = None
with requests.post(URL, json=body, stream=True, timeout=(10, 120),
                   headers={"x-goog-api-key": os.environ["GEMINI_API_KEY"]}) as r, \
        open("response.txt", "a", encoding="utf-8") as out:
    r.raise_for_status()
    for line in r.iter_lines(decode_unicode=True):
        if not line or not line.startswith("data:"):
            continue
        event = json.loads(line[5:])
        for cand in event.get("candidates", []):
            for part in cand.get("content", {}).get("parts", []):
                out.write(part.get("text", ""))
        out.flush()
        usage = event.get("usageMetadata", usage)
print(usage)

timeout=(10, 120) définit un délai d'attente de connexion de 10 secondes et un délai d'attente de lecture de 120 secondes. Dans requests, le délai d'attente de lecture est l'intervalle le plus long entre les octets, et non la durée totale, de sorte qu'un flux qui continue d'envoyer peut s'exécuter aussi longtemps que nécessaire. Chaque morceau est écrit sur le disque au fur et à mesure de son arrivée. Sur 3.8 Flash, chaque événement contient un usageMetadata en cours, de sorte que le dernier vous donne les comptes de jetons finaux à enregistrer et à facturer.

Délais d'attente à chaque étape

Votre client est une étape. Un flux long traverse également un proxy inverse, une passerelle API, un équilibreur de charge, et peut-être un environnement d'exécution sans serveur, et n'importe lequel d'entre eux peut interrompre la réponse prématurément :

Surveillez une coupure fixe. Si les réponses longues échouent toujours au même temps écoulé, une étape a une limite de durée stricte que le streaming ne peut pas corriger, et ce travail doit être déplacé hors du chemin de la requête.

Exécutez les tâches longues en arrière-plan

Pour les tâches les plus longues, retirez le travail d'une connexion active. L'API Interactions prend en charge l'exécution en arrière-plan pour les tâches de longue durée en utilisant background=true. Les exécutions en arrière-plan dépendent des interactions stockées : la documentation indique que store=false est incompatible avec l'exécution en arrière-plan, alors laissez le stockage activé pour ces requêtes. Pour récupérer une interaction en arrière-plan terminée, suivez la documentation de Google ; ne devinez pas les points de terminaison de sondage. Comme Google indique que de nouveaux modèles sont lancés sur l'API Interactions, prévoyez que les tâches longues d'Argon s'exécutent là.

Plafonnez la sortie volontairement

La limite de 1 million est un plafond, pas un objectif. Sur generateContent, generationConfig.maxOutputTokens plafonne chaque réponse ; l'exemple de streaming définit 60 000. Sur 3.8 Flash, la réflexion compte pour ce plafond : notre test plafonné à 2 000 a renvoyé 1 340 jetons de pensée et 656 jetons visibles. Pour l'API Interactions, confirmez le champ de plafond de sortie dans la documentation de Google avant de vous y fier. Choisissez ensuite le plafond en fonction du coût que vous acceptez par appel :

Une réponse qui atteint le plafond s'arrête prématurément, il faut donc la considérer comme incomplète. Vérifiez le finishReason de l'événement final : MAX_TOKENS signifie que le plafond l'a interrompu. Ensuite, soit vous continuez lors d'un tour de suivi, soit vous augmentez le plafond pour cette tâche.

Stocker et analyser d'énormes sorties sans mise en mémoire tampon

Un million de jetons représente des mégaoctets de texte par réponse. Quelques règles empêchent cela de faire tomber un travailleur :

• Écrivez les morceaux au fur et à mesure qu'ils arrivent, dans un fichier ou un téléchargement d'objet multipartie, au lieu de construire une seule chaîne en mémoire.
• Conservez le fichier partiel si la connexion se coupe. Un nouvel essai à l'aveugle génère, et facture, la sortie à nouveau.
• Demandez des lignes JSON lorsque vous avez besoin d'une structure, afin que chaque ligne soit analysée indépendamment au lieu d'attendre la fermeture d'un document géant.
• Enregistrez usageMetadata et un compte d'octets, pas les corps complets.
• Vérifiez les limites de colonnes et de taille de message dans votre base de données et votre file d'attente avant qu'une réponse de 800K jetons ne les atteigne.

Testez-le dans Apidog avant l'ouverture de l'accès

Vous pouvez répéter tout cela avec un substitut. Téléchargez Apidog et effectuez trois vérifications.

Surveillez le flux. Envoyez la requête de streaming contre 3.8 Flash avec GEMINI_API_KEY et GEMINI_MODEL comme variables d'environnement. Apidog analyse les réponses text/event-stream et affiche chaque événement dans sa vue Chronologie au fur et à mesure de son arrivée, afin que vous puissiez voir les tailles des morceaux, les lacunes et le usageMetadata final.

Diffusez une fausse réponse beaucoup plus longue. La sortie réelle de 3.8 Flash plafonne à 65 536 jetons, alors exécutez une maquette locale qui diffuse beaucoup plus avec la même forme d'événement :

# long_stream_mock.py: SSE de forme Gemini pour les tests d'analyseur et de délai d'attente (fausses données)
import json, time
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer

EVENTS, DELAY, CHUNK = 20000, 0.005, "lorem ipsum " * 40

class Handler(BaseHTTPRequestHandler):
    def do_POST(self):
        self.rfile.read(int(self.headers.get("Content-Length", 0)))
        self.send_response(200)
        self.send_header("Content-Type", "text/event-stream")
        self.end_headers()
        for i in range(EVENTS):
            event = {"candidates": [{"content": {"parts": [{"text": CHUNK}]}}]}
            if i == EVENTS - 1:  # fake counts sized like a near-max reply
                event["usageMetadata"] = {"promptTokenCount": 1200,
                    "candidatesTokenCount": 950000, "thoughtsTokenCount": 40000,
                    "totalTokenCount": 991200}
            self.wfile.write(f"data: {json.dumps(event)}\n\n".encode())
            self.wfile.flush()
            time.sleep(DELAY)

ThreadingHTTPServer(("127.0.0.1", 8787), Handler).serve_forever()

Dirigez l'URL de base d'un environnement « mock » vers http://127.0.0.1:8787 et envoyez la même requête de streaming à travers elle. Le flux dure environ deux minutes (128 secondes dans notre test) et transporte 9,6 millions de caractères de texte, suffisamment pour exposer un analyseur de mise en mémoire tampon, un proxy qui retient les événements, ou un délai d'attente trop court.

Affirmez sur les comptes de jetons. Sur une requête generateContent sans streaming, affirmez que candidatesTokenCount plus thoughtsTokenCount dans usageMetadata reste égal ou inférieur à votre plafond et que le coût calculé reste inférieur à votre plafond aux prix d'Argon. Le guide de l'API Argon dispose d'un script de coût prêt à l'emploi.

FAQ

1 million est-il la fenêtre de contexte de Gemini 4 Argon ? Non. 1 million est la limite de sortie par réponse, contre 64K précédemment. Google n'a pas publié la fenêtre d'entrée d'Argon.

Combien coûte une réponse Argon de 1 million de jetons ? 10 $ de sortie aux tarifs d'introduction et 20 $ au tarif standard, plus l'entrée. Voir la tarification de Gemini 4 Argon pour plus de scénarios.

Puis-je générer une réponse de 1 million de jetons aujourd'hui ? Non, à moins que votre organisation ne fasse partie de la cohorte Fairwind ayant accès à Argon. Gemini 3.8 Flash et 3.1 Pro Preview plafonnent la sortie à 65 536 jetons, et Vals AI indique une sortie maximale de 262K pour la configuration Argon qu'il a testée.

Dois-je diffuser en continu les longues réponses Argon ? Google n'a pas publié de guide de streaming pour Argon, mais un appel sans streaming qui dure plusieurs minutes est exposé à chaque délai d'inactivité de votre pile. Diffusez-le, ou utilisez l'exécution en arrière-plan sur l'API Interactions.

Comment la limite de sortie d'Argon se compare-t-elle à GPT-6 Astra et Claude Opus 5.5 ? Les deux plafonnent la sortie synchrone à 128K ; Anthropic autorise 300K en mode Batch avec un en-tête bêta. Le 1 million déclaré d'Argon est environ 8 fois supérieur.

Votre prochaine étape

Ajoutez le streaming et un plafond de sortie à votre client Gemini maintenant, sur 3.8 Flash, et exécutez-le contre le long flux simulé jusqu'à ce que rien dans votre pile ne l'interrompe. Lorsque l'ID d'Argon sera livré, modifiez GEMINI_MODEL et réexécutez les mêmes tests dans Apidog.