Gemini Decision 1 vs Jev : prix, latence et configuration Python

Testez Gemini Decision 1 pour le routage multimodal et plusieurs vérifications indépendantes sur une même entrée. Prenez Jev comme première référence pour le routage de texte lorsque la latence et le coût sont prioritaires. Utilisez un modèle génératif pour produire du code, des explications, des valeurs extraites non prédéfinies ou des arguments d’outils.

Google a lancé Gemini Decision 1 le 11 novembre 2026. Au 2026-11-13, Decisions API est accessible via Gemini API, avec une prise en charge Python dans google-genai 3.2.0 et versions ultérieures. Il s’agit d’un endpoint de décision, pas d’un modèle destiné à remplacer celui d’un chat de programmation.

Que renvoie Gemini Decision 1 ?

Gemini Decision 1 évalue des résultats prédéfinis au lieu de générer une réponse token par token. Vous fournissez une entrée partagée et jusqu’à 1,000 questions indépendantes. La fenêtre de contexte est de 262,144 tokens, généralement présentée comme 256K. L’entrée et les questions doivent tenir ensemble dans cette limite.

Le guide de Decisions API décrit trois types de questions :

Type	À définir dans la requête	À lire dans la réponse
`noul`	Une question oui/non ; des critères facultatifs précisent chaque résultat.	`noul`, la probabilité de « oui », ainsi que `confidence`.
`choice`	Entre 2 et 255 options nommées, accompagnées de descriptions.	Le choix gagnant `choice`, les `probabilities` normalisées et `confidence`.
`score`	Une grille d’évaluation ordonnée dont le premier niveau porte l’indice 0.	Un `score` pondéré par les probabilités, les `probabilities` de chaque niveau et `confidence`.

Dans un agent de programmation, ces types répondent à des questions distinctes. La tâche exige-t-elle de consulter le dépôt ? Quel outil faut-il exécuter ensuite ? Quelle ampleur d’investigation faut-il prévoir ?

Les questions sont indépendantes. Une question ne peut pas utiliser la réponse d’une autre dans la même requête. Combinez les résultats dans le code de votre application. Envoyez une autre requête lorsqu’une décision ultérieure nécessite un résultat précédent.

Une confiance élevée pour noul ne signifie pas forcément « oui ». Le SDK définit noul comme une probabilité comprise entre 0.01 et 0.99. Sa confiance vaut max(noul, 1 - noul). Un résultat noul = 0.03 signifie donc « non », avec une confiance de 0.97.

Pour score, la valeur peut se situer entre deux niveaux de la grille. Sa confiance correspond à la probabilité la plus élevée d’un niveau individuel. Ce n’est pas la probabilité que la moyenne continue soit exactement correcte. Tenez compte de ces différences lorsque votre code applique des seuils.

Si vous connaissez déjà Jev, vous pouvez rapprocher ces types des modèles d’utilisation de notre guide des cas d’usage de Jev. Des concepts similaires ne rendent pas les formats de requête des fournisseurs interchangeables.

Gemini Decision 1 vs Jev : que montrent les mesures ?

Jev constitue la meilleure référence initiale pour un routeur exclusivement textuel lorsque vos propres résultats de qualité sont comparables. Testez Gemini séparément lorsque la prise en charge native de plusieurs modalités change la manière de traiter la tâche.

Les tarifs directs ci-dessous proviennent de la page de tarification de Google et de l’explication des prix de TypeSafe. Les résultats des tests proviennent des fiches Gemini Decision 1 et Jev 1.14 d’Artificial Analysis. Tous ont été vérifiés le 2026-11-13.

Mesure	Gemini Decision 1	Jev 1.14
ID du modèle en accès direct	`gemini-decision-1`	`jev-1.14.0`
Prix direct des entrées, en USD par 1M tokens	$0.10	$0.042
Facturation directe des tokens de sortie	$0	$0
Artificial Analysis Decision Index	66	66
Coût AA pour 1M tâches de benchmark, en USD	$345	$156
Temps par tâche AA, Time per Task	211 ms	92 ms

Les chiffres d’AA favorisent Jev en coût et en temps, pour un même score arrondi dans l’indice. Ils ne démontrent pas une précision égale sur vos questions de sélection d’outils. Les tâches du benchmark diffèrent aussi des requêtes HTTP. Ne multipliez pas ces chiffres par votre nombre de requêtes.

Google annonce une avance sur son propre ensemble de tests de lancement. L’entreprise rapporte aussi un coût presque 5x inférieur à celui de Gemini 3.5 Flash-Lite via Interactions API sur les tests communs. Cette comparaison diffère de l’indice d’AA. Elle n’établit pas une avance universelle sur Jev.

Dans son analyse du lancement du 12 novembre, Artificial Analysis indiquait un Brier score de 0.18 pour Gemini et de 0.19 pour Jev. Cette mesure de l’erreur des probabilités est meilleure lorsqu’elle est plus basse. Ce faible écart global ne suffit pas à définir un seuil de confiance sûr pour votre application.

La latence annoncée par Google correspond elle aussi à des conditions précises : une médiane de 50–100 ms de calcul du modèle et 150–250 ms de bout en bout. Ces chiffres concernent des contextes allant jusqu’à 16K tokens, avec une latence presque stable de 1 à 100 questions. Ne les extrapolez pas à 1,000 questions ni à un contexte complet de 256K.

Pour les tâches multimodales, la différence est plus nette. Google documente une prise en charge native du texte, des images, de l’audio, de la vidéo et des PDF. La référence des modèles de TypeSafe mentionne le texte et les images, mais pas l’audio ni la vidéo en natif. TypeSafe qualifie aussi les fonctions d’image d’expérimentales dans son annonce de Jev 1.14.

Commencez par Gemini pour les décisions portant sur des enregistrements, des vidéos ou des PDF. Commencez par Jev pour un routeur de texte existant. Révisez l’un ou l’autre choix si un test sur des données annotées montre moins d’erreurs, une latence acceptable et un coût total inférieur.

Comment l’entrée partagée modifie-t-elle la facture ?

Envoyez ensemble les questions liées lorsqu’elles évaluent la même entrée. Google facture cette entrée partagée une seule fois par requête. Chaque question ajoute toutefois les tokens de ses instructions, de ses critères et de son formatage.

Avec le tarif direct payant vérifié le 2026-11-13 :

request cost in USD =
(shared input tokens + all question tokens) × $0.10 / 1,000,000

Prenons une estimation avec 10,000 tokens d’entrée partagée et 100 questions. Supposons que chaque question ajoute 80 tokens facturables, formatage compris.

Organisation des requêtes	Entrée facturée estimée	Coût direct estimé
Une requête contenant 100 questions	10,000 + 100 × 80 = 18,000 tokens	$0.0018
100 requêtes distinctes répétant l’entrée	100 × (10,000 + 80) = 1,008,000 tokens	$0.1008

Cette comparaison porte sur deux façons d’envoyer des requêtes à Gemini. Elle ne prétend pas que l’évaluation d’une entrée partagée soit propre à Google.

L’estimation exclut les nouvelles tentatives, les appels ultérieurs à d’autres modèles et les frais de passerelle. Elle ne tient compte d’aucune remise ni d’aucun quota gratuit. Utilisez result.usage.total_input_tokens pour remplacer la quantité supposée de tokens par la consommation observée.

Regrouper des questions dans une requête interactive n’équivaut pas non plus à soumettre un traitement par lots asynchrone. La page de tarification de Google précise que Gemini Decision 1 ne prend pas en charge Batch API.

Exécuter un exemple de sélection d’outils en Python

Utilisez directement Gemini API pour le premier test. Vous évitez ainsi que la conversion du schéma d’une passerelle complique la vérification initiale.

La version du SDK fixée ci-dessous nécessite Python 3.11 ou une version ultérieure. Créez une clé en suivant les instructions de Google sur les clés d’API, puis vérifiez les régions prises en charge.

Utilisez une entrée synthétique pour l’essai. Consultez les conditions du service Gemini API avant d’envoyer le contenu d’un dépôt privé.

Installer le SDK et charger la clé

Exécutez ces commandes dans Bash. La saisie de la clé reste masquée et sa valeur n’est pas enregistrée en clair dans l’historique des commandes.

python3 -m venv .venv
source .venv/bin/activate
python -m pip install "google-genai==3.2.0"
read -rs GEMINI_API_KEY && export GEMINI_API_KEY

L’exemple transmet explicitement cette variable d’environnement au client. Il utilise v1beta et client.decisions.create, plutôt qu’une méthode de génération de texte. L’équivalent REST direct est POST https://generativelanguage.googleapis.com/v1beta/decisions.

Transformer la réponse en plan de routage

Enregistrez ce code dans route_decision.py. Il pose les trois types de questions, valide les types des réponses et affiche un plan de routage exploitable par un programme.

import json
import os

from google import genai
from google.genai.decisions import ChoiceAnswer, NoulAnswer, ScoreAnswer

api_key = os.environ.get("GEMINI_API_KEY")
if not api_key:
    raise SystemExit("Set GEMINI_API_KEY before running this script.")

client = genai.Client(
    api_key=api_key,
    http_options={"api_version": "v1beta"},
)

try:
    result = client.decisions.create(
        model="gemini-decision-1",
        input=(
            "Task: Explain why parse_config rejects an empty YAML file. "
            "Repository: Python service with src/config.py and "
            "tests/test_config.py. No file contents are provided. "
            "Start with read-only investigation."
        ),
        questions={
            "needs_repo": {
                "type": "noul",
                "instructions": "Must the next step inspect repository files?",
            },
            "next_tool": {
                "type": "choice",
                "instructions": "Choose the next read-only investigation step.",
                "criteria": {
                    "read_repo": "Inspect existing source files or tests.",
                    "read_docs": "Look up public API behavior.",
                    "no_tool": "The supplied text is sufficient.",
                    "human_review": "The task is ambiguous or outside these options.",
                },
            },
            "effort": {
                "type": "score",
                "instructions": "Rate the investigation effort this task needs.",
                "criteria": [
                    "Simple lookup or local explanation.",
                    "Investigation across source code and tests.",
                    "Architecture or security analysis with several dependencies.",
                ],
            },
        },
    )
except Exception as exc:
    raise SystemExit(
        f"Decision request failed ({type(exc).__name__}); no action selected."
    ) from None

answers = result.answers or {}
repo = answers.get("needs_repo")
tool = answers.get("next_tool")
effort = answers.get("effort")
if not (
    isinstance(repo, NoulAnswer)
    and isinstance(tool, ChoiceAnswer)
    and isinstance(effort, ScoreAnswer)
    and result.usage is not None
):
    raise SystemExit("Incomplete decision response; send this task for review.")

# Illustrative thresholds. Tune them on labeled traffic before deployment.
next_tool = tool.choice if tool.confidence >= 0.85 else "human_review"
if next_tool == "read_repo" and repo.noul < 0.85:
    next_tool = "human_review"
if next_tool not in {"read_repo", "read_docs", "no_tool", "human_review"}:
    next_tool = "human_review"

model_tier = (
    "reasoning"
    if effort.score >= 1.5 or effort.confidence < 0.80
    else "small"
)

print(json.dumps({
    "next_tool": next_tool,
    "model_tier": model_tier,
    "repository_probability": repo.noul,
    "tool_confidence": tool.confidence,
    "effort_score": effort.score,
    "input_tokens": result.usage.total_input_tokens,
    "output_tokens": result.usage.total_output_tokens,
}, indent=2))

Exécutez-le depuis la même session Bash :

python route_decision.py

Un appel réussi renvoie des réponses sous les trois clés demandées et indique zéro token de sortie. Le script doit afficher une étiquette d’outil, une étiquette de niveau de modèle, des probabilités et la consommation. Ne considérez pas une probabilité ou une route précise comme un résultat garanti.

Les seuils 0.85, 0.80 et 1.5 illustrent une politique d’application. Ce ne sont pas des recommandations du fournisseur. Les chaînes small et reasoning sont des étiquettes locales de routage, pas des ID de modèles d’API.

Le programme produit un plan. Il ne lit pas de fichiers, n’exécute pas de commandes et n’appelle pas le niveau de modèle sélectionné. Le contrôleur de votre agent doit associer ces étiquettes à des outils autorisés et à des modèles déployés. Gérez les permissions du système de fichiers et l’approbation des commandes séparément du jugement du modèle.

La même séparation s’applique à l’automatisation métier. Notre processus de routage des tickets avec Jev explique comment intégrer la classification dans un traitement avec validation et transfert pour examen.

Quels sont les quotas gratuits et les erreurs probables ?

Vérifiez les quotas de requêtes et de tokens avant un test de charge. Un nombre élevé de questions autorisées ne supprime pas les limites de débit.

Les limites publiées pour Gemini Decision 1, vérifiées le 2026-11-13, comprennent :

Niveau d’utilisation	Requêtes par minute	Tokens d’entrée par minute	Requêtes par jour
Free	200	50,000	10,000
Tier 1	1,500	1,000,000	50,000

Consultez les limites actives du projet dans AI Studio avant le déploiement. Google précise que les limites publiées ne garantissent pas la capacité disponible. D’autres niveaux payants figurent dans la référence liée.

Si le client n’a pas d’attribut decisions, vérifiez le paquet installé avec python -m pip show google-genai. Mettez-le à jour dans l’environnement virtuel qui exécute le script. La prise en charge de Decisions a été ajoutée au SDK 3.2.0.

En cas d’erreur liée aux limites de débit, réduisez la fréquence des requêtes ou le volume d’entrée avant de réessayer. Le guide de dépannage de Google recommande un délai exponentiel, une variation aléatoire appelée jitter et un nombre limité de tentatives pour les erreurs temporaires. Un quota journalier épuisé exige d’attendre sa réinitialisation ou de demander une augmentation. Une boucle de tentatives rapprochées ne résout pas ce problème.

Pour la modération de contenu, prévoyez un autre traitement des erreurs. Decisions API peut renvoyer 400 Bad Request au lieu de réponses lorsque ses filtres de sécurité bloquent l’entrée. Une requête bloquée ne signifie pas que la vérification de la politique a répondu « non ». Envoyez ce cas pour examen ou vers une autre procédure autorisée. N’interprétez pas l’absence de réponse comme une permission de poursuivre.

La même requête fonctionne-t-elle sur OpenRouter et Vercel ?

Les deux services proposent google/gemini-decision-1, mais leurs interfaces diffèrent de l’exemple Python direct de Google. Choisissez une passerelle en fonction de votre intégration existante. Changer uniquement l’URL de base ne suffit pas.

La fiche du modèle sur OpenRouter le répertorie. Sa référence Decisions API documente POST https://openrouter.ai/api/alpha/decisions, avec le contenu partagé dans state. L’endpoint est en phase alpha et son schéma peut changer. La fiche indique aussi que le routage régional au sein de l’UE n’est pas disponible pour le moment.

La documentation de lancement de Vercel mentionne le même ID de modèle. Les entrées PDF, audio et vidéo nécessitent le parcours AI SDK 7 décrit dans cette documentation. Son API compatible TypeSafe et son interface Decisions API prennent en charge le texte et les images.

La documentation des interfaces de décision de Vercel présente aussi des structures différentes selon l’interface. AI SDK utilise state et boolean. L’interface HTTP Decisions utilise input et predicate. Ne copiez pas une requête Google contenant noul sans l’adapter au schéma documenté.

La présence du modèle chez une passerelle ne prouve pas son accessibilité depuis tous les pays ni le respect d’une exigence de résidence des données. Vérifiez les conditions d’accès, le traitement des données et les frais de passerelle avant de transférer du trafic de production.

Que mesurer avant de remplacer un routeur ?

Exécutez d’abord le routeur candidat sans lui permettre de contrôler les actions. Comparez ses routes proposées à des exemples annotés et aux décisions de votre système actuel.

Mesurez les actions automatiques incorrectes à taux d’automatisation constant. Relevez aussi la fréquence du recours à une solution de repli, la latence de bout en bout p50 et p95, les nouvelles tentatives et le coût total. Vérifiez de nouveau les seuils après un changement de version du modèle, de formulation des questions ou de liste d’options.

Gardez les traitements déterministes dans le code. Un modèle de décision apporte peu à la vérification d’un code de sortie connu ou à l’application d’une règle de permission exacte. Un modèle génératif reste adapté pour produire un correctif, une explication ou un appel d’outil avec de nouveaux arguments.

Pour les processus de programmation, incluez dans la comparaison le coût et les échecs du modèle chargé d’exécuter la tâche choisie. Notre guide du coût par tâche des agents de programmation explique pourquoi un appel de routage moins cher peut augmenter le coût de la tâche terminée.