Gemini Decision 1 vs Jev: precios, latencia y configuración en Python

Prueba Gemini Decision 1 para el enrutamiento multimodal y varias comprobaciones independientes sobre una misma entrada. Usa Jev como primera referencia para enrutar texto cuando la latencia y el costo sean prioritarios. Recurre a un modelo generativo cuando necesites código, explicaciones, valores extraídos que no estén predefinidos o argumentos para herramientas.

Google lanzó Gemini Decision 1 el 11 de noviembre de 2026. A fecha de 2026-11-13, Decisions API está disponible mediante Gemini API, con soporte para Python en google-genai 3.2.0 y versiones posteriores. Es un endpoint de decisiones, no un sustituto del modelo de un chat de programación.

¿Qué devuelve Gemini Decision 1?

Gemini Decision 1 evalúa resultados predefinidos en lugar de generar una respuesta token a token. Proporcionas una entrada compartida y hasta 1,000 preguntas independientes. La ventana de contexto es de 262,144 tokens, normalmente descrita como 256K. La entrada y las preguntas deben caber juntas en ese límite.

La guía de Decisions API documenta tres tipos de preguntas:

Tipo	Qué defines en la solicitud	Qué lees en la respuesta
`noul`	Una pregunta de sí o no; los criterios opcionales aclaran cada resultado.	`noul`, la probabilidad de sí, junto con `confidence`.
`choice`	Entre 2 y 255 opciones con nombre y descripción.	La opción ganadora `choice`, las `probabilities` normalizadas y `confidence`.
`score`	Una escala de evaluación ordenada cuyo primer nivel tiene el índice 0.	Un `score` ponderado por probabilidades, las `probabilities` de cada nivel y `confidence`.

En un agente de programación, estos tipos pueden responder preguntas distintas. ¿La tarea necesita contexto del repositorio? ¿Qué herramienta debe ejecutarse a continuación? ¿Cuánta investigación requiere la tarea?

Las preguntas son independientes. Una pregunta no puede utilizar la respuesta de otra dentro de la misma solicitud. Combina los resultados en el código de tu aplicación. Haz otra solicitud cuando una decisión posterior necesite un resultado anterior.

Una confianza alta en noul no significa necesariamente «sí». El SDK define noul como una probabilidad entre 0.01 y 0.99. Su confianza es max(noul, 1 - noul). Por tanto, noul = 0.03 significa un «no» con una confianza de 0.97.

En score, el valor puede quedar entre dos niveles de la escala. Su confianza es la mayor probabilidad de un nivel individual. No es la probabilidad de que el promedio continuo sea exactamente correcto. Ten en cuenta estas diferencias al aplicar umbrales en tu código.

Si ya conoces Jev, puedes relacionar estos tipos con los patrones de nuestra guía de casos de uso de Jev. Que los conceptos se parezcan no hace intercambiables los formatos de solicitud de los proveedores.

Gemini Decision 1 vs Jev: ¿qué muestran las mediciones?

Jev es la mejor referencia inicial para un enrutador exclusivamente textual cuando tus propios resultados de calidad son comparables. Prueba Gemini por separado cuando la entrada multimodal nativa cambie cómo resuelves la tarea.

Las tarifas directas siguientes proceden de la página de precios de Google y de la explicación de precios de TypeSafe. Los resultados de las pruebas proceden de los perfiles de Gemini Decision 1 y Jev 1.14 en Artificial Analysis. Todos se comprobaron el 2026-11-13.

Medida	Gemini Decision 1	Jev 1.14
ID del modelo para acceso directo	`gemini-decision-1`	`jev-1.14.0`
Precio directo de entrada, USD por 1M tokens	$0.10	$0.042
Cargo directo por tokens de salida	$0	$0
Artificial Analysis Decision Index	66	66
Costo de AA por 1M tareas de sus pruebas, USD	$345	$156
Tiempo por tarea de AA, Time per Task	211 ms	92 ms

Las cifras de AA favorecen a Jev en costo y tiempo con la misma puntuación redondeada del índice. No demuestran que ambos tengan la misma precisión en tus preguntas de selección de herramientas. Las tareas de las pruebas tampoco equivalen a solicitudes HTTP. No multipliques estas cifras por tu número de solicitudes.

Google declara que lidera su propio conjunto de pruebas de lanzamiento. También informa de un costo casi 5x menor que Gemini 3.5 Flash-Lite mediante Interactions API en las pruebas compartidas. Esa comparación es distinta del índice de AA y no demuestra una ventaja universal sobre Jev.

En su análisis del lanzamiento del 12 de noviembre, Artificial Analysis informó de un Brier score de 0.18 para Gemini y de 0.19 para Jev. En esta medida del error de las probabilidades, cuanto menor, mejor. Esa pequeña diferencia agregada no establece un umbral de confianza seguro para tu aplicación.

La latencia que declara Google también tiene un alcance concreto: una mediana de 50–100 ms de cómputo del modelo y 150–250 ms de extremo a extremo. Se refiere a contextos de hasta 16K tokens, con una latencia casi constante entre 1 y 100 preguntas. No extiendas esa afirmación a 1,000 preguntas ni a un contexto completo de 256K.

La diferencia es más clara en tareas multimodales. Google documenta entradas nativas de texto, imágenes, audio, video y PDF. La referencia de modelos de TypeSafe enumera texto e imágenes, pero no audio ni video nativos. TypeSafe también describe las funciones de imagen como experimentales en su anuncio de Jev 1.14.

Empieza con Gemini para tomar decisiones sobre grabaciones, videos o PDF. Empieza con Jev para un enrutador de texto existente. Cambia cualquiera de esas elecciones si una prueba con datos etiquetados muestra menos errores, una latencia aceptable y un menor costo total.

¿Cómo cambia la factura al compartir la entrada?

Envía juntas las preguntas relacionadas cuando evalúen la misma entrada. Google factura esa entrada compartida una sola vez por solicitud. Cada pregunta sigue añadiendo los tokens de sus instrucciones, criterios y formato.

Con la tarifa directa de pago comprobada el 2026-11-13:

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

Considera una estimación con 10,000 tokens de entrada compartida y 100 preguntas. Supón que cada pregunta aporta 80 tokens facturables, incluido el formato.

Diseño de las solicitudes	Entrada facturada estimada	Costo directo estimado
Una solicitud con 100 preguntas	10,000 + 100 × 80 = 18,000 tokens	$0.0018
100 solicitudes separadas que repiten la entrada	100 × (10,000 + 80) = 1,008,000 tokens	$0.1008

Esta comparación evalúa dos formas de enviar solicitudes a Gemini. No afirma que Google sea el único proveedor que evalúa preguntas sobre una entrada compartida.

La estimación excluye los reintentos, las llamadas posteriores a otros modelos y los cargos del gateway. No contempla descuentos ni una cuota gratuita. Usa result.usage.total_input_tokens para sustituir la cantidad supuesta de tokens por el consumo observado.

Combinar preguntas en una solicitud interactiva también es distinto de enviar un trabajo por lotes asíncrono. La página de precios de Google indica que Gemini Decision 1 no admite Batch API.

Ejecuta un ejemplo de selección de herramientas en Python

Usa Gemini API directamente para la primera prueba. Así evitas que la adaptación del esquema del gateway complique la comprobación inicial.

Necesitas Python 3.11 o posterior para la versión del SDK fijada a continuación. Crea una clave siguiendo las instrucciones de Google sobre claves de API y comprueba las regiones admitidas.

Usa una entrada sintética para la prueba. Consulta las condiciones del servicio Gemini API antes de enviar contenido de un repositorio privado.

Instala el SDK y carga la clave

Ejecuta estos comandos en Bash. La clave no se muestra mientras la escribes y su valor no queda como texto literal en el historial.

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

El ejemplo pasa explícitamente esa variable de entorno al cliente. Usa v1beta y client.decisions.create, en lugar de un método de generación de texto. El equivalente REST directo es POST https://generativelanguage.googleapis.com/v1beta/decisions.

Convierte la respuesta en un plan de enrutamiento

Guarda este código como route_decision.py. Plantea los tres tipos de preguntas, valida los tipos de respuesta y muestra un plan de enrutamiento legible por máquinas.

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))

Ejecútalo desde la misma sesión de Bash:

python route_decision.py

Una llamada correcta devuelve respuestas bajo las tres claves solicitadas e informa de cero tokens de salida. El script debería mostrar una etiqueta de herramienta, una etiqueta de nivel de modelo, probabilidades y consumo. No des por garantizada una probabilidad o ruta concreta.

Los umbrales 0.85, 0.80 y 1.5 ilustran una política de la aplicación; no son recomendaciones del proveedor. Las cadenas small y reasoning son etiquetas locales de enrutamiento, no ID de modelos de la API.

El programa genera un plan. No lee archivos, ejecuta comandos ni llama al nivel de modelo seleccionado. El controlador de tu agente debe asociar estas etiquetas con herramientas autorizadas y modelos desplegados. Mantén los permisos del sistema de archivos y la aprobación de comandos separados de la evaluación del modelo.

La misma separación se aplica a la automatización empresarial. Nuestro flujo de enrutamiento de tickets con Jev explica cómo encaja la clasificación en un proceso con validación y derivación a revisión.

¿Cuáles son los límites gratuitos y los fallos más probables?

Comprueba tanto la cuota de solicitudes como la de tokens antes de una prueba de carga. Un límite alto de preguntas no elimina los límites de frecuencia.

Los límites publicados de Gemini Decision 1, comprobados el 2026-11-13, incluyen:

Nivel de uso	Solicitudes por minuto	Tokens de entrada por minuto	Solicitudes por día
Free	200	50,000	10,000
Tier 1	1,500	1,000,000	50,000

Comprueba los límites activos del proyecto en AI Studio antes del despliegue. Google advierte de que los límites publicados no garantizan capacidad. La referencia enlazada incluye otros niveles de pago.

Si el cliente no tiene el atributo decisions, revisa el paquete instalado con python -m pip show google-genai. Actualízalo en el mismo entorno virtual que ejecuta el script. El soporte de Decisions se incorporó en el SDK 3.2.0.

Ante errores por límites de frecuencia, reduce la frecuencia de las solicitudes o el volumen de entrada antes de reintentar. La guía de resolución de problemas de Google recomienda una espera exponencial, variación aleatoria o jitter y reintentos limitados para fallos transitorios. Si agotas la cuota diaria, necesitas esperar a que se restablezca o solicitar un aumento. Un bucle de reintentos rápidos no lo resolverá.

Para moderar contenido, prepara otra vía de tratamiento de errores. Decisions API puede devolver 400 Bad Request en lugar de respuestas cuando sus filtros de seguridad bloquean la entrada. Que se bloquee una solicitud no significa que la comprobación de la política haya respondido «no». Envía ese caso a revisión o a otra vía autorizada. No interpretes la ausencia de respuestas como permiso para continuar.

¿Sirve la misma solicitud en OpenRouter y Vercel?

Ambos incluyen google/gemini-decision-1, pero sus interfaces difieren del ejemplo directo de Google en Python. Elige un gateway según la integración que ya uses. No basta con cambiar la URL base.

La página del modelo en OpenRouter lo incluye en su catálogo. Su referencia de Decisions API documenta POST https://openrouter.ai/api/alpha/decisions, con el contenido compartido en state. El endpoint está en fase alpha y su esquema puede cambiar. La página del modelo también indica que aún no está disponible el enrutamiento regional dentro de la Unión Europea.

La documentación de lanzamiento de Vercel incluye el mismo ID de modelo. Las entradas PDF, de audio y de video requieren la vía de AI SDK 7 descrita allí. Sus API compatible con TypeSafe y Decisions admiten texto e imágenes.

La documentación de interfaces de decisiones de Vercel también presenta estructuras distintas según la interfaz. AI SDK usa state y boolean; su interfaz HTTP de Decisions usa input y predicate. No copies una solicitud de Google con noul sin adaptarla antes al esquema documentado.

Que un gateway incluya el modelo no demuestra que puedas acceder desde cualquier país ni que cumpla un requisito de residencia de datos. Comprueba las condiciones de acceso, el tratamiento de los datos y los cargos del gateway antes de trasladar tráfico de producción.

¿Qué debes medir antes de sustituir un enrutador?

Ejecuta primero el enrutador candidato sin permitirle controlar acciones. Compara sus rutas propuestas con ejemplos etiquetados y con las decisiones de tu sistema actual.

Mide las acciones automáticas incorrectas manteniendo fija la proporción de automatización. Registra también la frecuencia de derivación a una alternativa, la latencia de extremo a extremo p50 y p95, los reintentos y el costo total. Revisa los umbrales tras cambiar la versión del modelo, la redacción de las preguntas o la lista de opciones.

Mantén las tareas deterministas en el código. Un modelo de decisión aporta poco al comprobar un código de salida conocido o aplicar una regla exacta de permisos. Un modelo generativo sigue siendo adecuado cuando necesitas un parche, una explicación o una llamada a una herramienta con argumentos nuevos.

En procesos de programación, incluye en la comparación el costo y los fallos del modelo que ejecuta la tarea seleccionada. Nuestra guía del costo por tarea de los agentes de programación explica por qué una llamada de enrutamiento más barata puede encarecer la tarea terminada.