Niveaux de réflexion de Gemini 4 Neon : quand utiliser High ou xhigh

Gemini 4 Neon dispose de quatre niveaux de réflexion et utilise par défaut le niveau high. Voici comment définir thinking_level dans l’Interactions API et generateContent, ce que coûte chaque niveau et quand passer de high à xhigh.

INEZA Felin-Michel

INEZA Felin-Michel

19 November 2026

Niveaux de réflexion de Gemini 4 Neon : quand utiliser High ou xhigh

Apidog pour les entreprises

Déploiement sur site

SSO & RBAC

Conforme SOC 2

Découvrir Apidog Enterprise

Les niveaux de réflexion de Gemini 4 Neon offrent quatre réglages pour déterminer l'intensité du raisonnement du modèle avant qu'il ne réponde : low, medium, high et xhigh. Neon est réglé sur high par défaut. Google recommande de conserver high pour la plupart des tâches complexes et de passer à xhigh uniquement lorsque high échoue sur des problèmes difficiles à plusieurs étapes, car xhigh consomme plus de tokens et prend plus de temps.

Que sont les niveaux de réflexion de Gemini 4 Neon ?

Les niveaux de réflexion sont les valeurs du paramètre thinking_level qui définissent l'ampleur du raisonnement interne effectué par gemini-4-neon avant de rédiger une réponse. Neon en prend en charge quatre : low, medium, high (par défaut) et xhigh. Les niveaux élevés utilisent davantage de tokens de réflexion et ajoutent de la latence ; les niveaux bas répondent plus vite et coûtent moins cher.

Voici comment le guide de réflexion de Google décrit chaque niveau pour Neon :

thinking_level Consommation de tokens Usage suggéré par Google
low Le moins de tokens, la latence la plus faible Chat rapide, traitement à haut débit ; reste performant sur les tâches agentiques
medium Consommation de tokens réduite, réponses plus rapides Codage interactif, prototypage d'UI en direct, appels d'outils sensibles à la latence
high (par défaut) Équilibre entre intelligence et rapidité Codage complexe, exécution agentique, appels d'outils, travail de connaissance multimodale
xhigh Le plus de tokens, raisonnement le plus approfondi Ingénierie difficile à plusieurs étapes, problèmes analytiques et scientifiques où high ne suffit pas

Deux valeurs que vous pourriez attendre sont absentes. Neon rejette minimal avec une erreur, donc du code copié depuis une application Gemini 3 Flash casse s'il envoie cette valeur. Et l'ancien comptage de tokens thinkingBudget est déprécié sur Gemini 4 : envoyé seul, il est rattaché au niveau le plus proche avec un avertissement ; envoyé en même temps que thinkingLevel, il renvoie un 400.

Échelle des quatre niveaux de réflexion de Gemini 4 Neon, de low à xhigh, avec les tokens de réflexion et la latence qui augmentent à chaque étape et high marqué comme valeur par défaut

Comment le réglage par défaut de Neon se compare-t-il aux autres modèles Gemini 4 ?

Neon démarre un cran plus haut que ses grands frères. D'après les notes de version de Gemini 4 Neon, Neon et Hydrogen sont réglés sur high par défaut et prennent en charge xhigh, tandis que Carbon et Argon sont réglés sur medium par défaut et plafonnent à high.

Modèle Niveau par défaut Niveaux pris en charge
gemini-4-neon high low, medium, high, xhigh
gemini-4-hydrogen high low, medium, high, xhigh
gemini-4-carbon medium low, medium, high
gemini-4-argon medium low, medium, high

Cela compte lorsque vous changez de modèle. Déplacez une charge de travail Carbon vers Neon sans définir thinking_level et chaque requête passe d'un raisonnement medium à high, ce qui modifie votre nombre de tokens. Si vous comparez les modèles plus grands, notre comparatif Gemini 4 Carbon vs Argon couvre cette distinction.

Comment définir thinking_level dans l'API Gemini ?

Neon fonctionne sur le palier payant de l'Interactions API et de generateContent. Le nom du champ diffère entre les deux.

Interactions API : placez thinking_level dans generation_config.

curl "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -X POST \
  -d '{
    "model": "gemini-4-neon",
    "input": "Audit this payment retry queue for race conditions.",
    "generation_config": {
      "thinking_level": "xhigh",
      "max_output_tokens": 65536
    }
  }'

generateContent : utilisez thinkingLevel dans generationConfig.thinkingConfig.

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-4-neon:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -X POST \
  -d '{
    "contents": [{"parts": [{"text": "Audit this payment retry queue for race conditions."}]}],
    "generationConfig": {
      "thinkingConfig": {"thinkingLevel": "medium"}
    }
  }'

Dans le SDK Python, l'appel Interactions prend generation_config={"thinking_level": "high"}, et l'appel generateContent prend thinking_config=types.ThinkingConfig(thinking_level="low"). Laissez de côté temperature, top_p et top_k : Google indique que Neon ignore les valeurs dans les plages autorisées et rejette celles hors plage avec un 400. Pour un guide complet de première requête sur la même conception d'API, consultez notre guide de l'API Gemini 4 Hydrogen.

Quand utiliser high plutôt que xhigh ?

Utilisez high par défaut et ne passez une tâche à xhigh qu'après que high a échoué à votre niveau de qualité requis sur cette tâche. L'annonce de Google présente xhigh comme un « raisonnement approfondi à plusieurs étapes pour les charges de travail d'ingénierie, d'analyse et scientifiques les plus difficiles ».

Choisissez xhigh lorsque :

Restez sur high (ou descendez plus bas) lorsque :

Les chiffres de benchmark de Google confirment cette séparation. Dans son annonce de lancement, Neon en xhigh obtient 61 à l'Artificial Analysis Intelligence Index, au troisième rang. Au niveau par défaut high, Google rapporte un coût par tâche inférieur de 32 % à celui de Carbon. Ce sont les chiffres de Google, pas nos tests, mais ils illustrent le compromis : xhigh offre le meilleur score de Neon, high offre l'efficacité.

Combien coûte chaque niveau de réflexion ?

Chaque niveau a le même prix par token ; ce qui change, c'est le nombre de tokens que vous payez. Neon coûte 3,00 $ par 1 M de tokens d'entrée et 15,00 $ par 1 M de tokens de sortie, et la page de tarification de Google précise que le tarif de sortie inclut les tokens de réflexion. L'entrée mise en cache tombe à 0,15 $ par 1 M via la mise en cache implicite (la mise en cache explicite n'est pas prise en charge sur Neon). Il n'existe pas de palier gratuit pour ce modèle.

Ainsi, le coût d'un niveau correspond aux tokens de réflexion qu'il ajoute, multipliés par 15 $ par million. Voici le calcul pour une requête de 2 000 tokens d'entrée et une réponse visible de 800 tokens. Les nombres de tokens de réflexion sont hypothétiques, choisis pour illustrer le calcul, et non mesurés :

Tokens de réflexion (hypothétiques) Coût d'entrée Coût de sortie + réflexion Total par requête Pour 10 000 requêtes
500 0,006 $ 0,0195 $ 0,0255 $ 255 $
2 000 0,006 $ 0,042 $ 0,048 $ 480 $
8 000 0,006 $ 0,132 $ 0,138 $ 1 380 $

La réflexion domine vite la facture. À 8 000 tokens de réflexion, le raisonnement représente 87 % du coût de la requête. C'est pourquoi Google recommande lui-même de tester votre évaluation aux quatre niveaux et de « choisir le thinking_level le plus bas qui satisfait votre niveau de qualité requis ». Notre guide des niveaux de réflexion de Gemini 3.8 Flash couvre le même compromis sur un modèle moins cher si vous souhaitez comparer.

Comment mesurer les tokens et la latence par niveau ?

Exécutez le même prompt à chaque niveau et lisez le bloc d'utilisation. Dans l'Interactions API, l'objet usage de la réponse indique séparément total_input_tokens, total_output_tokens et total_thought_tokens. Dans generateContent, les tokens de réflexion apparaissent sous usageMetadata.thoughtsTokenCount.

Cette boucle envoie un prompt aux quatre niveaux et affiche les tokens de réflexion ainsi que le temps réel écoulé :

for level in low medium high xhigh; do
  start=$(date +%s)
  usage=$(curl -s "https://generativelanguage.googleapis.com/v1beta/interactions" \
    -H "x-goog-api-key: $GEMINI_API_KEY" \
    -H 'Content-Type: application/json' \
    -d "{\"model\":\"gemini-4-neon\",
         \"input\":\"Find the race condition in this retry loop: ...\",
         \"generation_config\":{\"thinking_level\":\"$level\",\"max_output_tokens\":65536}}" \
    | jq -c '{status, thought: .usage.total_thought_tokens, out: .usage.total_output_tokens}')
  echo "$level $(( $(date +%s) - start ))s $usage"
done

Exécutez-la sur 10 à 20 prompts issus de votre charge de travail réelle. Un seul prompt vous apprendra peu ; un ensemble montre où high et xhigh commencent à diverger en termes de qualité.

Réglez un timeout élevé sur votre client HTTP pendant vos tests. Les notes de migration de Google indiquent que les prompts difficiles peuvent prendre plusieurs minutes et suggèrent un timeout d'au moins 15 minutes, ou une exécution en arrière-plan.

Pourquoi xhigh renvoie-t-il parfois une réponse vide ?

max_output_tokens plafonne ensemble la réflexion et la sortie visible. Si Neon dépense tout le budget en raisonnement, l'interaction s'arrête avec le statut incomplete et renvoie une réponse tronquée ou vide, et vous payez quand même les tokens de réflexion générés.

Trois règles issues de la documentation de Google permettent d'éviter cela :

  1. Supprimez les anciens plafonds trop bas. Si votre application code en dur quelque chose comme 8 192, portez-le à 65 536, la limite synchrone par défaut.
  2. Baissez le niveau, pas le plafond. Pour réduire le coût ou la latence, passez à medium ou low plutôt que de réduire max_output_tokens.
  3. Passez en arrière-plan pour les travaux longs. Pour des réponses dépassant 65 536 tokens, mettez background à true et max_output_tokens jusqu'à 1 048 576 moins votre entrée. L'entrée, la réflexion et la sortie partagent une seule fenêtre de 1 M de tokens. Notre guide des sorties longues de Gemini 4 Argon détaille le modèle de polling.

Laissez votre agent de codage benchmarker les quatre niveaux avec Apidog CLI

Relancer cette boucle à la main devient vite lassant. À la place, laissez votre agent de codage (Claude Code, Codex, Cursor) construire un test réutilisable avec Apidog CLI et le relancer à chaque niveau dès que vous voulez des chiffres frais.

Configurez-le une fois :

npm install -g apidog-cli@latest
apidog login --with-token <YOUR_TOKEN>
npx -y skills add https://apidog.com   # pick your agent when prompted

Donnez ensuite un prompt à votre agent :

In Apidog project <projectId>, create an environment "gemini" with base URL
https://generativelanguage.googleapis.com and variables GEMINI_API_KEY and
THINKING. Add an endpoint for POST /v1beta/interactions that sends the
x-goog-api-key header from GEMINI_API_KEY. Create a test case that sends model
"gemini-4-neon", my audit prompt, generation_config.thinking_level {{THINKING}}
and max_output_tokens 65536, and asserts: HTTP 200, status is "completed",
and usage.total_thought_tokens exists. Run it once per level (low, medium,
high, xhigh) and give me a table of thought tokens and response time.

L'agent lit chaque schéma de payload, valide son JSON, écrit les ressources et boucle l'exécution :

apidog environment create gemini --project <projectId> --base-url https://generativelanguage.googleapis.com
apidog cli-schema get endpoint-create
apidog cli-schema validate endpoint-create --file endpoint.json
apidog endpoint create --project <projectId> --file endpoint.json
apidog cli-schema validate test-case-create --file case.json
apidog test-case create --project <projectId> --file case.json
for level in low medium high xhigh; do
  apidog run --test-case <caseId> --project <projectId> -e <envId> \
    --env-var "THINKING=$level" -r cli,json --out-file "neon-$level"
done
Flux depuis un prompt d'agent passant par apidog environment create, endpoint create, test-case create et quatre commandes apidog run en low, medium, high et xhigh contre gemini-4-neon, pour aboutir à un tableau de comparaison vide pour les tokens de réflexion et le temps

L'assertion status is "completed" intercepte le piège incomplete de la section précédente, de sorte qu'un niveau qui épuise son budget échoue bruyamment au lieu de renvoyer une chaîne vide. Remplacez -r cli,json par -r junit et la même exécution s'intègre à votre CI ; le guide CI/CD d'Apidog CLI montre le pipeline, et Apidog CLI dans Claude Code couvre la configuration de l'agent. Le forfait gratuit d'Apidog couvre jusqu'à 4 utilisateurs.

FAQ

Quel est le niveau de réflexion par défaut de Gemini 4 Neon ? high. Vous n'avez pas besoin d'envoyer thinking_level pour l'obtenir. Carbon et Argon sont réglés sur medium par défaut, donc définissez le niveau explicitement lorsque vous migrez depuis ceux-ci.

Gemini 4 Neon prend-il en charge la réflexion minimale ? Non. Neon prend en charge low, medium, high et xhigh, et rejette minimal avec une erreur. Utilisez low pour les réponses les plus rapides et les moins chères.

Les tokens de réflexion sont-ils facturés sur Gemini 4 Neon ? Oui. Les tokens de réflexion sont facturés au tarif de sortie de 15,00 $ par 1 M. Google compte chaque token traité par le modèle, y compris les tokens de réflexion.

Puis-je encore utiliser thinkingBudget avec Gemini 4 Neon ? C'est déprécié sur les modèles Gemini 4. Envoyé seul, il est rattaché au thinkingLevel le plus proche et renvoie un avertissement. Envoyé en même temps que thinkingLevel, la requête échoue avec un 400.

xhigh est-il toujours plus précis que high ? Pas toujours. Google indique que xhigh peut sur-réfléchir sur des prompts simples comme l'extraction de texte ou de JSON et peut épuiser max_output_tokens. Testez les deux sur vos propres prompts et conservez le niveau le plus bas qui passe.

Puis-je utiliser les niveaux de réflexion de Gemini 4 Neon gratuitement ? Non. Gemini 4 Neon n'est pas disponible sur le palier gratuit de l'API Gemini. Dans Google AI Studio et Google Antigravity, il est lié aux forfaits payants Google AI Pro et Ultra.

Pratiquez le Design-first d'API dans Apidog

Découvrez une manière plus simple de créer et utiliser des API