Saltar al contenido principal

Gemini Decisions API: prueba del nuevo modelo de decisiones de Google en latencia y coste

Descubre cómo Gemini Decision 1 puntúa opciones fijas sin generar texto, crea un clasificador de intenciones con la Decisions API y compáralo con Gemini 3.5 Flash-Lite en precisión, latencia, calibración y coste.
· 15 min leer

Explora con IA

La mayoría de las apps con LLM están llenas de microdecisiones: ¿qué herramienta debe llamar el agente?, ¿qué modelo debe gestionar esta consulta?, ¿este mensaje incumple alguna política?

Hoy, muchos equipos responden a estas preguntas pidiéndole a un modelo generativo que escriba la respuesta como texto y luego parsean ese texto para tomar una decisión.

La Gemini Decisions API de Google propone otro enfoque. Usa el modelo Gemini Decision 1 para puntuar un conjunto fijo de opciones en una sola pasada y devuelve una probabilidad para cada opción, sin facturar tokens de salida.

En este tutorial, ejecutaremos la misma tarea de clasificación de intenciones con dos configuraciones:

  • Gemini Decision 1 a través de la Decisions API
  • Gemini 3.5 Flash-Lite a través de la Interactions API, con salida JSON estructurada

Los compararemos en precisión, latencia, uso de tokens, coste y calibración, y luego pasaremos de 1 a 100 preguntas en una sola solicitud.

Al final del tutorial, sabrás cómo:

  • Llamar a la Decisions API con preguntas choice y leer sus probabilidades y puntuaciones de confianza

  • Crear una línea base generativa con la Interactions API y un esquema JSON

  • Medir la latencia, el uso de tokens y el coste en ambos enfoques

  • Comprobar si la confianza de un modelo es fiable con un diagrama de fiabilidad y el error de calibración esperado (ECE)

  • Decidir cuándo un modelo de decisiones encaja mejor en tu app que uno generativo

Puedes ejecutar el código completo en este Google Colab.

Modelos de decisión vs. modelos generativos

Antes de ver cómo funciona cada uno, definamos ambos términos.

  • Modelo generativo: genera contenido nuevo. Le das un prompt y escribe la respuesta token a token. Esa respuesta puede ser una contestación, un resumen, código o una etiqueta. Gemini 3.5 Flash-Lite, como la mayoría de LLMs que usamos en apps de chat, es un modelo generativo.
  • Modelo de decisiones: elige entre las opciones que defines. Le das una entrada y una lista fija de posibles respuestas, y te devuelve la probabilidad de cada opción sin escribir una sola línea de texto. Gemini Decision 1 es un modelo de decisiones.

Aquí tienes un ejemplo. 

Una clienta escribe a un banco: "Mi tarjeta aún no ha llegado. ¿Cuándo llegará?"

Si le preguntas a un modelo generativo: "¿Qué quiere esta clienta?", podría responder:

«La clienta está esperando una tarjeta nueva y quiere saber cuándo llegará».

Es una buena respuesta para que la lea una persona. Pero si tu app necesita enrutar el mensaje al equipo adecuado, tu código tiene que convertir esa frase en una etiqueta. Puedes forzar una etiqueta con un esquema JSON, pero el modelo seguirá "escribiéndola" token a token.

En cambio, si preguntas lo mismo a un modelo de decisiones, primero le pasas las opciones, por ejemplo card_arrival, lost_or_stolen_card y exchange_rate. Devuelve una probabilidad por cada una:

card_arrival         0.91
lost_or_stolen_card  0.06
exchange_rate        0.03

Tu código puede actuar directamente sobre esa probabilidad: enrutar al equipo de tarjetas si card_arrival supera un umbral y mandarlo a una persona si no. En resumen:

 

Modelo generativo

Modelo de decisiones

Devuelve

Texto que escribe

Una probabilidad por cada opción que defines

Respuestas posibles

Abiertas

Conjunto fijo

Bueno para

Respuestas, resúmenes, explicaciones y extracción

Enrutado, selección de herramientas, comprobaciones de políticas y evaluación

En la práctica, muchas apps usan un modelo generativo para ambos trabajos. Eso es lo que probaremos a continuación: si un modelo de decisiones hace mejor la parte de clasificación que uno generativo.

Cuando usas un modelo generativo como clasificador, escribe la respuesta token a token. Para una respuesta JSON como la nuestra, la salida va generándose así:

{
{"intent":
{"intent": "card_arrival",
{"intent": "card_arrival", "confidence": 0.95}

Cada token es un paso de decodificación distinto y cada token de salida se factura. Si quieres una puntuación de confianza, el modelo también tiene que escribir ese número. Ese número es la propia estimación del modelo sobre sí mismo, no una probabilidad medida en sus internos.

Un modelo de decisiones, en cambio, se salta la fase de escritura. Le das las opciones por adelantado y puntúa todas frente a la entrada en una pasada. El resultado es una probabilidad para cada opción:

card_arrival            0.12
card_delivery_estimate  0.85
lost_or_stolen_card     0.01
...

Esto cambia tres cosas que puedes medir:

  • Latencia: no hay bucle de decodificación, así que la latencia no debería crecer con la longitud de la respuesta.
  • Coste: no hay tokens de salida que facturar. Solo pagas por los tokens de entrada, que incluyen el texto de la pregunta y las descripciones de las opciones.
  • Confianza: la confianza proviene de las propias probabilidades, por lo que debería reflejar con qué frecuencia acierta el modelo.

La contrapartida es que solo puedes hacer preguntas de conjunto cerrado. Un modelo de decisiones no puede explicar su respuesta, extraer un valor ni escribir texto libre.

Demo: crear un clasificador de intenciones bancarias

En esta demo, construiremos un clasificador de intenciones bancarias. Usaremos la partición de test de Banking77, un dataset público de mensajes de clientes etiquetados con 77 intenciones, y nos quedaremos con 12 intenciones fáciles de confundir entre sí:

  • card_arrival y card_delivery_estimate

  • pending_card_payment, declined_card_payment y card_payment_fee_charged

  • pending_transfer, transfer_not_received_by_recipient y balance_not_updated_after_bank_transfer

  • lost_or_stolen_card, card_not_working, exchange_rate y top_up_failed

Intenciones similares hacen la tarea más difícil, lo que vuelve más interesante analizar las puntuaciones de confianza.

Ejecutaremos el clasificador con ambos modelos de dos formas:

  • Un mensaje por solicitud: 180 mensajes (15 por intención), enviados a cada modelo uno a uno.
  • Muchas preguntas por solicitud: N mensajes en una entrada compartida, con una pregunta por mensaje, para N = 1, 5, 10, 25, 50 y 100.

Estos son los ajustes que mantenemos iguales en ambos modelos:

Ajuste

Valor usado

Por qué 

Modelo de decisiones

gemini-decision-1

El modelo bajo prueba

Modelo generativo

gemini-3.5-flash-lite

La línea base generativa rentable usada en el post de lanzamiento

Temperatura de Flash-Lite

0.0

Elimina el ruido de muestreo de la línea base

Nivel de pensamiento de Flash-Lite

minimal

Mantiene la comparación en la decodificación, no en el razonamiento

Formato de salida

Esquema JSON con un enum de las 12 etiquetas

Flash-Lite solo puede devolver una etiqueta válida

Descripciones de opciones

Una frase corta por intención

Ambos modelos ven las mismas definiciones de etiquetas

Llamadas de calentamiento

2 por modelo

Saca la configuración de conexión de las medidas

Repeticiones (muchas preguntas por solicitud)

3 por ajuste

Reportamos la mediana, no una sola ejecución

Nota: Son ajustes funcionales para esta demo, no configuraciones afinadas para ninguno de los modelos.

Paso 1: requisitos previos y configuración

Para seguir el tutorial, necesitas:

  • Una clave de la Gemini API desde Google AI Studio

  • Un cuaderno de Colab (o cualquier entorno de Python 3)

  • google-genai versión 3.2 o posterior

La Decisions API tiene un nivel sin coste en Google AI Studio para prototipado, así que puedes probarla antes de pagar. Yo ejecuté esta demo en Colab, pero usa cualquier entorno Python 3 que prefieras. 

Empecemos instalando los paquetes:

!pip install -q -U "google-genai>=3.2" pandas matplotlib

Aquí, google-genai es el SDK de Google en Python para la Gemini API. Nos da los métodos client.decisions.create y client.interactions.create, que envían solicitudes a la Decisions API y a la Interactions API. Usamos pandas para cargar el dataset y organizar resultados, y matplotlib para representar las figuras.

Después creamos el cliente. La Decisions API necesita la versión v1beta del API:

import os, time, json
import numpy as np
import pandas as pd
from google import genai
client = genai.Client(
    api_key=os.environ["GEMINI_API_KEY"],
    http_options={"api_version": "v1beta"},
)

DECISION_MODEL = "gemini-decision-1"
GEN_MODEL = "gemini-3.5-flash-lite"

Aquí, genai.Client() lee la clave de API de GEMINI_API_KEY definida en los secretos de Colab o como variable de entorno, y http_options la dirige al API v1beta, donde está la Decisions API. 

Luego cargaremos el dataset Banking77 y definiremos nuestras 12 intenciones. Cada intención tiene una descripción de una frase que verán ambos modelos:

BANKING77_URL = (
    "https://raw.githubusercontent.com/PolyAI-LDN/task-specific-datasets/master/banking_data/test.csv"
)
INTENTS = {
    "card_arrival": "The customer is asking where their new card is or why it has not arrived yet.",
    "card_delivery_estimate": "The customer wants to know how long card delivery usually takes.",
    "lost_or_stolen_card": "The customer's card was lost or stolen.",
    # ... 9 more intents
}
LABELS = list(INTENTS)

df = pd.read_csv(BANKING77_URL)
df = df[df["category"].isin(LABELS)].reset_index(drop=True)

sample = (
    df.groupby("category")
      .sample(n=15, random_state=42)
      .sample(frac=1, random_state=42)
      .reset_index(drop=True)
)

El fragmento anterior descarga la partición de test de Banking77 como CSV y mantiene solo las filas con una de nuestras 12 intenciones. Luego toma 15 mensajes por intención con una semilla fija para reproducibilidad. El .sample(frac=1) final baraja las filas para mezclar intenciones.

Esto nos da 180 mensajes, 15 por intención.

Paso 2: clasificar con la Decisions API

Una pregunta de tipo choice recibe un diccionario que asigna cada ID de opción a una descripción. Pasamos el mensaje como input y hacemos una única pregunta, con clave intent:

def decide_intent(text):
    start = time.perf_counter()
    result = client.decisions.create(
        model=DECISION_MODEL,
        input=text,
        questions={
            "intent": {
                "type": "choice",
                "instructions": "Which intent best describes this banking customer message?",
                "criteria": INTENTS,
            }
        },
    )
    latency = time.perf_counter() - start
    ans = result.answers["intent"]
    return {
        "pred": ans.choice,
        "confidence": float(ans.confidence),
        "probabilities": dict(ans.probabilities),
        "latency_s": latency,
        "input_tokens": result.usage.total_input_tokens,
        "output_tokens": result.usage.total_output_tokens,
    }

La función decide_intent() envía un mensaje como input y una pregunta choice con nuestras 12 intenciones como opciones. Medimos el tiempo con time.perf_counter() y luego leemos la opción superior, la confianza, todas las probabilidades y los contadores de tokens de la respuesta.

Cada respuesta incluye tres campos:

  • choice: la opción con mayor probabilidad

  • probabilities: una probabilidad por opción, sumando 1

  • confidence: la probabilidad estimada de que la respuesta superior sea correcta

El objeto usage informa los tokens de entrada, y total_output_tokens siempre es 0.

Este es el resultado para el primer mensaje de nuestra muestra:

El modelo confundió dos intenciones similares, pero su confianza de 0,846 refleja cierta incertidumbre. Lo bueno es que la intención correcta, card_arrival, quedó segunda con casi toda la probabilidad restante (alrededor de 0,15). El resto de opciones, casi a cero.

Paso 3: clasificar con Flash-Lite

Para la línea base generativa, usamos salida estructurada con un enum de las mismas 12 etiquetas, así Flash-Lite solo puede devolver una etiqueta válida. También pedimos una confianza entre 0 y 1, que es como la mayoría de apps obtienen una puntuación de confianza de un modelo generativo:

LABEL_LIST = "\n".join(f"- {k}: {v}" for k, v in INTENTS.items())

GEN_SCHEMA = {
    "type": "object",
    "properties": {
        "intent": {"type": "string", "enum": LABELS},
        "confidence": {"type": "number"},
    },
    "required": ["intent", "confidence"],
}

def generate_intent(text):
    prompt = (
        "Which intent best describes this banking customer message?\n\n"
        f"Intents:\n{LABEL_LIST}\n\n"
        f"Message: {text}\n\n"
        "Return the intent and your confidence from 0 to 1."
    )
    start = time.perf_counter()
    interaction = client.interactions.create(
        model=GEN_MODEL,
        input=prompt,
        response_format={
            "type": "text",
            "mime_type": "application/json",
            "schema": GEN_SCHEMA,
        },
        generation_config={"temperature": 0.0, "thinking_level": "minimal"},
        store=False,
    )
    latency = time.perf_counter() - start
    parsed = json.loads(interaction.output_text)
    return {
        "pred": parsed["intent"],
        "confidence": float(parsed["confidence"]),
        "latency_s": latency,
        "input_tokens": interaction.usage.total_input_tokens,
        "output_tokens": interaction.usage.total_output_tokens,
        "thought_tokens": interaction.usage.total_thought_tokens,
    }

La función generate_intent() construye un prompt con las 12 intenciones y sus descripciones. Llama a Flash-Lite con response_format establecido a nuestro esquema JSON, por lo que la salida debe ser JSON válido con una de las 12 etiquetas. La temperatura es 0 y el nivel de pensamiento minimal para mantener la respuesta estable y corta. Luego parseamos interaction.output_text con json.loads() y leemos los contadores de tokens de interaction.usage.

Probé el mismo mensaje del paso anterior con Flash-Lite y cometió el mismo error con mayor confianza:

Los thinking tokens son 0, lo que confirma que minimal limitó a Flash-Lite a escribir solo la respuesta. Flash-Lite usó menos tokens de entrada que Decision 1 (277 vs 337) porque la Decisions API cuenta las descripciones de las opciones dentro de la pregunta como entrada.

Paso 4: clasificar un mensaje por solicitud

Ahora, enviemos los 180 mensajes a ambos modelos, una solicitud cada vez, tras dos llamadas de calentamiento por modelo:

rows = []
for i, r in sample.iterrows():
    for model_name, fn in (("decision", decide_intent), ("generative", generate_intent)):
        out = fn(r["text"])
        rows.append({
            "model": model_name, "gold": r["category"], "pred": out["pred"],
            "confidence": out["confidence"], "latency_s": out["latency_s"],
            "input_tokens": out["input_tokens"], "output_tokens": out["output_tokens"],
        })

exp1 = pd.DataFrame(rows)
exp1["correct"] = exp1["pred"] == exp1["gold"]

Este bucle envía cada mensaje a ambas funciones y guarda la predicción, la confianza, la latencia y los tokens como una fila. Luego convertimos las filas en un DataFrame y añadimos una columna correct que marca si cada predicción coincide con la etiqueta real.

Estos son los resultados:

Métrica

Gemini Decision 1

Gemini 3.5 Flash-Lite

Precisión

84,4%

83,9%

Latencia mediana

325 ms

1.068 ms

p90 de latencia

412 ms

6.483 ms

Solicitud más lenta

1,0 s

101,6 s

Solicitudes > 5 s

0 de 180

33 de 180

Media de tokens de entrada

339

279

Media de tokens de salida

0

25

Tres conclusiones que aprendimos de estas métricas:

  • Precisión: ambos modelos fueron igual de precisos, aproximadamente.
  • Latencia: Decision 1 fue ~3 veces más rápido en la mediana y mucho más consistente, mientras que Flash-Lite tuvo una cola larga de solicitudes lentas.
  • Tokens: Decision 1 usó más tokens de entrada porque las descripciones de opciones cuentan como entrada, pero no generó tokens de salida.

Nota: Nuestro cronometraje incluye el viaje de red desde Colab, así que considera esa diferencia como dependiente del entorno.

Paso 5: comprobar la calibración

La precisión indica con qué frecuencia acierta un modelo, pero la calibración nos dice si su confianza significa algo o no. Un modelo está bien calibrado cuando su confianza coincide con su precisión; es decir, si dice 0,8 en un grupo de respuestas, alrededor del 80% deberían ser correctas.

Para medirlo, agrupamos predicciones en 10 intervalos de confianza y comparamos la confianza media de cada uno con su precisión. El error de calibración esperado (ECE) es la media ponderada de las diferencias, según cuántas predicciones caen en cada intervalo. Cuanto menor, mejor.

def ece(conf, correct, n_bins=10):
    conf = np.asarray(conf, dtype=float)
    correct = np.asarray(correct, dtype=float)
    edges = np.linspace(0, 1, n_bins + 1)
    ids = np.clip(np.digitize(conf, edges[1:-1]), 0, n_bins - 1)
    total = 0.0
    for b in range(n_bins):
        mask = ids == b
        if mask.sum():
            total += mask.mean() * abs(conf[mask].mean() - correct[mask].mean())
    return total

La función ece() coloca cada predicción en uno de 10 intervalos por su confianza (0–0,1; 0,1–0,2; etc.). Para cada intervalo, toma la diferencia entre la confianza media y la precisión, la pondera por la proporción de predicciones en ese intervalo y suma los resultados.

Así comparan ambos modelos:

Métrica

Gemini Decision 1

Gemini 3.5 Flash-Lite

Precisión

84,4%

83,9%

Confianza media

0,867

0,957

ECE

0,050

0,124

Confianza media cuando acierta

0,901

0,966

Confianza media cuando falla

0,686

0,912

Figura: diagramas de fiabilidad de ambos modelos

La confianza de Decision 1 está cerca de su precisión, con un ECE de 0,050. Además, es claramente menor cuando el modelo se equivoca (0,686) que cuando acierta (0,901).

Flash-Lite es sobreconfiado. Informa 0,957 de media mientras acierta el 83,9% de las veces. Usó solo 9 valores de confianza distintos en 180 respuestas, y 158 de ellas fueron 0,95 o más. Incluso sus respuestas erróneas promediaron 0,912. El número parece una probabilidad, pero es la estimación que el propio modelo escribe como texto.

La calibración importa cuando actúas según la puntuación. Un patrón habitual es aceptar respuestas por encima de un umbral de confianza y enviar el resto a un modelo de respaldo o a una persona:

Umbral

Decision 1: porcentaje conservado

Decision 1: precisión en conservados

Flash-Lite: porcentaje conservado

Flash-Lite: precisión en conservados

0,50

94,4%

85,9%

99,4%

84,4%

0,70

78,3%

92,2%

98,9%

84,3%

0,80

74,4%

93,3%

98,9%

84,3%

0,90

63,3%

95,6%

88,9%

87,5%

0,95

53,9%

96,9%

87,8%

87,3%

Con Decision 1, un umbral más alto funciona como esperas. Al 0,9, conserva el 63% de mensajes con un 95,6% de precisión. Con Flash-Lite, el umbral apenas ayuda porque la mayoría de sus errores también tienen alta confianza. La documentación oficial recomienda elegir umbral con ejemplos etiquetados de tu propio tráfico.

Paso 6: clasificar 100 mensajes en una solicitud

La Decisions API puede responder hasta 1.000 preguntas sobre una entrada compartida en una sola solicitud. Para probarlo, ponemos N mensajes de clientes en una entrada y hacemos una pregunta por mensaje.

Para Decision 1, eso significa N preguntas choice con claves de m1 a mN:

def build_batch(n):
    msgs = pool.iloc[:n]
    shared = "Banking customer messages:\n" + "".join(
        f"Message {i + 1}: {t}\n" for i, t in enumerate(msgs["text"])
    )
    return shared, list(msgs["category"])

def decide_batch(n):
    shared, gold = build_batch(n)
    questions = {
        f"m{i + 1}": {
            "type": "choice",
            "instructions": f"Which intent best describes Message {i + 1}?",
            "criteria": INTENTS,
        }
        for i in range(n)
    }
    result = client.decisions.create(
        model=DECISION_MODEL, input=shared, questions=questions
    )
    preds = [result.answers[f"m{i + 1}"].choice for i in range(n)]
    return preds, gold, result.usage

Aquí, la función build_batch() numera los primeros N mensajes y los une en una entrada compartida. Luego decide_batch() crea una pregunta choice por mensaje, con claves de m1 a mN, los envía en una sola solicitud y lee una respuesta por clave.

Para Flash-Lite, enviamos la misma entrada compartida con un esquema JSON que tiene N campos, cada uno limitado a 12 etiquetas. Cada N usa los mismos mensajes en ambos modelos y cada ajuste se ejecuta tres veces.

Preguntas por solicitud

Decision 1: latencia mediana

Flash-Lite: latencia mediana

Decision 1: tokens de entrada

Flash-Lite: tokens de entrada / salida

1

318 ms

888 ms

344

291 / 14

5

353 ms

858 ms

1.554

369 / 64

10

398 ms

1.063 ms

3.056

456 / 129

25

546 ms

2.753 ms

7.570

710 / 350

50

592 ms

Falló

15.100

Falló

100

59.095 ms

Falló

30.309

Falló

Hasta 25 preguntas, la latencia mediana de Decision 1 se mantuvo por debajo de 550 ms. La mediana de Flash-Lite creció con N, de menos de 1 s con 1 a 5 preguntas a 2,75 s con 25, porque tiene que escribir cada respuesta como tokens de salida. Incluso con 50 preguntas, la mediana de Decision 1 fue 592 ms, aunque una de las tres ejecuciones tardó 70 s.

Dos puntos clave para reflexionar:

  • Flash-Lite falló con 50 y 100 preguntas: las filas "Falló" de la tabla anterior son el mismo error 400. Indica que el esquema "tiene demasiados estados para servir". Un esquema con 50 o más campos, cada uno limitado a 12 etiquetas, supera lo que acepta el API.
  • Decision 1 se ralentizó con 100 preguntas: cada pregunta repite las 12 descripciones de opciones, unos 300 tokens por pregunta, por lo que la solicitud alcanzó 30.309 tokens, mientras que la promesa de latencia plana de Google cubre contextos hasta 16K tokens.

Paso 7: recortar las solicitudes

Ahora surge una pregunta obvia: ¿podemos evitar la ralentización y los fallos? Para Decision 1, usamos descripciones de opciones vacías (""). Para Flash-Lite, pedimos una única lista de N etiquetas en lugar de N campos separados:

# Decision 1: solo IDs de opción, sin descripciones
"criteria": {k: "" for k in LABELS}

# Flash-Lite: un campo lista en lugar de N campos
schema = {
    "type": "object",
    "properties": {"intents": {
        "type": "array",
        "items": {"type": "string", "enum": LABELS},
        "minItems": n, "maxItems": n,
    }},
    "required": ["intents"],
}

Así le fue a Decision 1 con descripciones vacías:

Preguntas por solicitud

Latencia mediana

Precisión

Tokens de entrada

25

357 ms

84,0%

3.995

50

649 ms

78,0%

7.950

100

1.603 ms

83,0%

16.009

Eliminar las descripciones redujo aproximadamente a la mitad los tokens de entrada. Con 100 preguntas, la solicitud bajó a ~16K tokens y la latencia mediana cayó de 59 s a 1,6 s. La precisión bajó un poco con 25 y 50 preguntas, así que descripciones cortas son un mejor punto medio que ninguna, sobre todo para intenciones similares.

El esquema de lista no ayudó al modelo Flash-Lite. Funcionó con 25 preguntas, pero siguió fallando con 50 y 100.

Paso 8: comparar el coste

Por último, calculamos el coste a partir de los contadores de tokens que devuelve cada API, usando precios del nivel de pago:

Modelo

Precio de entrada por 1M tokens

Precio de salida por 1M tokens

Gemini Decision 1

$0,10

$0

Gemini 3.5 Flash-Lite

$0,30

$2,50 (incluye thinking tokens)

def cost_per_request(model, input_tokens, output_tokens, thought_tokens):
    if model == "decision":
        return input_tokens * 0.10 / 1e6
    return (input_tokens * 0.30 + (output_tokens + thought_tokens) * 2.50) / 1e6

La función cost_per_request() multiplica cada contador de tokens por su precio por 1M de tokens. En Decision 1 solo cuentan los tokens de entrada. En Flash-Lite, los thinking tokens se facturan al precio de salida, así que los sumamos a los de salida.

Este es el coste por 1.000 solicitudes en cada configuración:

Configuración

Gemini Decision 1

Gemini 3.5 Flash-Lite

Flash-Lite / Decision 1

1 mensaje por solicitud

$0,034

$0,147

4,3x

5 preguntas por solicitud

$0,155

$0,271

1,7x

10 preguntas por solicitud

$0,306

$0,459

1,5x

25 preguntas por solicitud

$0,757

$1,088

1,4x

25 preguntas, configuraciones recortadas (Paso 7)

$0,400

$0,831

2,1x

50 preguntas por solicitud

$1,510

Falló

n/a

100 preguntas, descripciones vacías

$1,601

Falló

n/a

En mensajes individuales, Decision 1 fue 4,3x más barato, pero la diferencia se reduce al agrupar más preguntas en una solicitud. La entrada compartida se factura una vez en ambas APIs. Pero cada pregunta de Decision 1 arrastra su propia instrucción y las 12 descripciones, mientras que Flash-Lite ve la lista de etiquetas una sola vez y paga una salida corta por respuesta. Con 25 preguntas, Decision 1 usó 7.570 tokens de entrada frente a 710 de entrada y 350 de salida de Flash-Lite.

Nota: La Decisions API no admite caché de contexto ni Batch API. Si envías la misma entrada en varias solicitudes, se factura completa cada vez. Así que, si tienes muchas preguntas sobre la misma entrada, hazlas en una sola solicitud en lugar de repartirlas.

Cuándo usar cada enfoque

Según lo anterior, un modelo de decisiones encaja mejor cuando:

  • La respuesta sale de un conjunto fijo de opciones, como intenciones, rutas, herramientas o etiquetas de políticas
  • La decisión va en la ruta de petición, donde cada persona usuaria espera a que termine
  • Quieres actuar según la confianza, por ejemplo, enviando los casos dudosos a un fallback o a una persona
  • Necesitas hacer muchas comprobaciones independientes sobre la misma entrada en una sola solicitud

Un modelo generativo sigue siendo mejor cuando:

  • Necesitas una explicación, un valor extraído o texto libre
  • El conjunto de posibles respuestas es abierto o cambia por solicitud
  • Ya hiciste una llamada generativa sobre esa entrada y puedes añadir la clasificación a ella

Usa la Decisions API cuando necesites

Usa la Interactions API cuando necesites

Una probabilidad sí/no, una opción de un conjunto fijo o una puntuación en una escala fija

Texto generado, resúmenes o explicaciones

Probabilidades calibradas que puedas umbralizar

Valores u objetos extraídos que sigan tu propio esquema JSON

Muchas comprobaciones independientes sobre la misma entrada en una llamada

Llamadas a herramientas con argumentos

Baja latencia y coste cero en tokens de salida

Razonamiento en varios pasos

Conclusiones

En este tutorial, construimos un clasificador de intenciones bancarias con Gemini Decision 1 y Gemini 3.5 Flash-Lite, y comparamos ambos modelos en precisión, latencia, calibración y coste. Cuatro ideas clave:

  • Empate en precisión: 84,4% para Decision 1 y 83,9% para Flash-Lite, con el mismo veredicto en 163 de 180 mensajes.
  • Decision 1 fue más rápido y predecible: latencia mediana de 325 ms frente a 1.068 ms, y la solicitud más lenta tardó 1,0 s frente a 101,6 s.
  • La confianza de Decision 1 fue utilizable: su ECE fue 0,050 frente a 0,124, y subir el umbral a 0,9 elevó la precisión en respuestas conservadas del 84,4% al 95,6%. La confianza autoinformada de Flash-Lite apenas separó aciertos de errores.
  • El coste y el escalado dependen de cómo plantees las preguntas: Decision 1 fue 4,3x más barato en mensajes sueltos, pero cada pregunta paga por sus descripciones de opción. Mantén el total de entrada por debajo de ~16K tokens y deja las descripciones lo más cortas posible.

Estos resultados salen de una tarea, un dataset y pocas ejecuciones desde un cuaderno de Colab. Tómalos como observaciones de una demo, no como afirmaciones generales de rendimiento. 

Aashi Dutt

Autor

Aashi Dutt

Soy experta Google Developers en ML (Gen AI), triple experta en Kaggle y embajadora de Women Techmakers, con más de tres años de experiencia en el sector tecnológico. Cofundé una startup de salud en 2020 y actualmente curso un máster en informática en Georgia Tech, con especialización en aprendizaje automático.

FAQs

¿Cuál es la diferencia entre la Decisions API y una API generativa?

Una API generativa escribe su respuesta token a token y factura cada token de salida. La Decisions API puntúa un conjunto fijo de opciones en una sola pasada y devuelve una probabilidad por cada una. No genera tokens de salida, así que solo pagas la entrada.

¿Es Gemini Decision 1 más preciso que Gemini 3.5 Flash-Lite?

No en nuestra prueba. En 180 mensajes bancarios, la precisión fue del 84,4% para Decision 1 y del 83,9% para Flash-Lite. Las diferencias estuvieron en latencia, calibración y coste.

¿Por qué Decision 1 usa más tokens de entrada que Flash-Lite?

Las instrucciones de cada pregunta y las descripciones de opciones cuentan como entrada. Con 12 opciones descritas, añadieron unos 300 tokens por pregunta en nuestra prueba. Descripciones cortas o vacías lo reducen.

¿La latencia se mantiene plana al añadir más preguntas?

En nuestras ejecuciones, la mediana se mantuvo por debajo de 650 ms hasta 50 preguntas. Con 100 preguntas y descripciones completas, la solicitud llegó a ~30K tokens y tardó de 48 a 59 s. Con descripciones vacías, las mismas 100 preguntas entraron en ~16K tokens y tardaron 1,6 s.

¿Qué tipos de pregunta admite la Decisions API?

Decisions API admite tres tipos de preguntas: noul para comprobaciones sí/no, choice para elegir una opción entre 2 y 255, y score para puntuar según una rúbrica ordenada. Puedes combinar las tres en una sola solicitud.

Temas

Relacionado

An avian AI exits its cage

blog

12 alternativas de código abierto a GPT-4

blog

10 maneras de utilizar ChatGPT para las finanzas