Zum Hauptinhalt springen

Gemini Decisions API: Googles neues Entscheidungsmodell im Test zu Latenz und Kosten

Lerne, wie Gemini Decision 1 feste Optionen ohne Textgenerierung bewertet, baue einen Banking-Intent-Classifier mit der Decisions API und vergleiche ihn mit Gemini 3.5 Flash-Lite bei Genauigkeit, Latenz, Kalibrierung und Kosten.
· 15 Min. lesen

Entdecke KI

Die meisten LLM-Apps bestehen aus vielen kleinen Entscheidungen: Welches Tool soll der Agent aufrufen? Welches Modell beantwortet diese Anfrage? Verstößt diese Nachricht gegen eine Richtlinie?

Heute beantworten viele Teams diese Fragen, indem sie ein generatives Modell um eine textliche Antwort bitten und diesen Text anschließend parsen, um eine Entscheidung abzuleiten.

Googles Gemini Decisions API geht einen anderen Weg. Sie nutzt das Gemini Decision 1 Modell, um in einem einzigen Forward-Pass eine feste Menge an Optionen zu bewerten und für jede Option eine Wahrscheinlichkeit zurückzugeben – bei null berechneten Ausgabetokens.

In diesem Tutorial führen wir dieselbe Intent-Klassifikation in zwei Setups aus:

  • Gemini Decision 1 über die Decisions API
  • Gemini 3.5 Flash-Lite über die Interactions API mit strukturiertem JSON-Output

Wir vergleichen Genauigkeit, Latenz, Tokenverbrauch, Kosten und Kalibrierung – und skalieren dann beide von 1 auf 100 Fragen in einer einzelnen Anfrage.

Am Ende weißt du, wie du:

  • Die Decisions API mit choice-Fragen aufrufst und ihre Wahrscheinlichkeiten sowie Konfidenzwerte ausliest

  • Einen generativen Baseline-Ansatz mit der Interactions API und einem JSON-Schema aufbaust

  • Für beide Ansätze Latenz, Tokenverbrauch und Kosten misst

  • Prüfst, ob die Modellkonfidenz verlässlich ist – mit Reliability Diagram und Expected Calibration Error (ECE)

  • Bewertest, wann ein Entscheidungsmodell besser zu deiner App passt als ein generatives

Den vollständigen Code kannst du in diesem Google Colab ausführen.

Entscheidungsmodelle vs. generative Modelle

Bevor wir ins Detail gehen, definieren wir die beiden Begriffe.

  • Generatives Modell: Dieses Modell erzeugt neuen Content. Du gibst einen Prompt, und es schreibt die Antwort Token für Token. Das kann z. B. eine Antwort, Zusammenfassung, Code oder ein Label sein. Gemini 3.5 Flash-Lite, wie die meisten LLMs in Chat-Apps, ist ein generatives Modell.
  • Entscheidungsmodell: Ein Entscheidungsmodell wählt aus den von dir definierten Optionen. Du gibst einen Input und eine feste Liste möglicher Antworten, und das Modell liefert für jede Option eine Wahrscheinlichkeit – ohne einen einzigen Texttoken zu generieren. Gemini Decision 1 ist ein Entscheidungsmodell.

Hier ein Beispiel. 

Eine Kundin schreibt an eine Bank: "Meine Karte ist noch nicht angekommen. Wann kommt sie?"

Fragst du ein generatives Modell: "Was will diese Kundin?", könnte es antworten:

„Die Kundin wartet auf eine neue Karte und möchte wissen, wann sie ankommt.“

Das ist für Menschen gut lesbar. Muss deine App die Nachricht aber an das richtige Team weiterleiten, muss dein Code diesen Satz in ein Label übersetzen. Du kannst ein Label per JSON-Schema erzwingen – das Modell schreibt es dennoch Token für Token.

Fragst du hingegen ein Entscheidungsmodell dasselbe, gibst du zuerst die Optionen vor, etwa card_arrival, lost_or_stolen_card und exchange_rate. Es gibt für jede eine Wahrscheinlichkeit zurück:

card_arrival         0.91
lost_or_stolen_card  0.06
exchange_rate        0.03

Dein Code kann dann direkt auf Basis der Wahrscheinlichkeit handeln: z. B. ans Kartenteam routen, wenn card_arrival über einem Schwellwert liegt – und sonst an eine Person übergeben. Kurz gesagt:

 

Generatives Modell

Entscheidungsmodell

Gibt zurück

Selbst verfassten Text

Eine Wahrscheinlichkeit für jede definierte Option

Mögliche Antworten

Offen

Feste Menge

Geeignet für

Antworten, Zusammenfassungen, Erklärungen und Extraktion

Routing, Toolauswahl, Policy-Checks und Bewertung

In der Praxis nutzen viele Apps ein generatives Modell für beides. Genau das testen wir als Nächstes: Ob ein Entscheidungsmodell die Klassifikation besser erledigt als ein generatives.

Wenn du ein generatives Modell als Klassifikator nutzt, schreibt es die Antwort Token für Token. Für eine JSON-Antwort wie unsere sieht der Stream während der Generierung so aus:

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

Jedes Token ist ein eigener Decoding-Schritt – und jedes Ausgabetoken wird berechnet. Willst du einen Konfidenzwert, muss das Modell auch diese Zahl schreiben. Diese Zahl ist die Eigeneinschätzung des Modells, keine intern gemessene Wahrscheinlichkeit.

Ein Entscheidungsmodell überspringt diesen Schreibschritt. Du gibst die Optionen vorab, und es bewertet alle gegen den Input in einem Forward-Pass. Das Ergebnis ist eine Wahrscheinlichkeit für jede Option:

card_arrival            0.12
card_delivery_estimate  0.85
lost_or_stolen_card     0.01
...

Das verändert drei messbare Dinge:

  • Latenz: Es gibt keine Decoding-Schleife, daher sollte die Latenz nicht mit der Antwortlänge wachsen.
  • Kosten: Es fallen keine Ausgabetokens an. Abgerechnet werden nur Eingabetokens – also dein Fragetext plus die Optionsbeschreibungen.
  • Konfidenz: Die Konfidenz ergibt sich aus den Wahrscheinlichkeiten selbst und sollte daher gut widerspiegeln, wie oft das Modell richtig liegt.

Der Trade-off: Du kannst nur Closed-Set-Fragen stellen. Ein Entscheidungsmodell erklärt seine Antwort nicht, extrahiert keine Werte und schreibt keinen Freitext.

Demo: Einen Banking-Intent-Classifier bauen

In dieser Demo bauen wir einen Intent-Classifier fürs Banking. Wir nutzen den Testsplit von Banking77, einem öffentlichen Datensatz mit Kundenanfragen und 77 Intents, und behalten 12 Intents, die leicht zu verwechseln sind:

  • card_arrival und card_delivery_estimate

  • pending_card_payment, declined_card_payment und card_payment_fee_charged

  • pending_transfer, transfer_not_received_by_recipient und balance_not_updated_after_bank_transfer

  • lost_or_stolen_card, card_not_working, exchange_rate und top_up_failed

Ähnliche Intents machen die Aufgabe anspruchsvoller – und die Konfidenzwerte spannender.

Wir lassen den Classifier mit beiden Modellen auf zwei Arten laufen:

  • Eine Nachricht pro Anfrage: 180 Nachrichten (15 pro Intent), jeweils einzeln an jedes Modell gesendet.
  • Viele Fragen pro Anfrage: N Nachrichten in einem gemeinsamen Input, mit je einer Frage pro Nachricht, für N = 1, 5, 10, 25, 50 und 100.

Das halten wir in beiden Modellen gleichs:

Einstellung

Wert

Begründung 

Entscheidungsmodell

gemini-decision-1

Das zu testende Modell

Generatives Modell

gemini-3.5-flash-lite

Kosteneffiziente generative Baseline aus dem Launch-Vergleich

Flash-Lite-Temperatur

0.0

Entfernt Sampling-Rauschen aus der Baseline

Flash-Lite Thinking Level

minimal

Hält den Vergleich beim Decoding, nicht beim Reasoning

Ausgabeformat

JSON-Schema mit einem enum der 12 Labels

Flash-Lite kann nur ein gültiges Label zurückgeben

Optionsbeschreibungen

Ein kurzer Satz pro Intent

Beide Modelle sehen dieselben Label-Definitionen

Warmup-Calls

2 pro Modell

Hält Verbindungsaufbau aus der Messung

Wiederholungen (viele Fragen pro Anfrage)

3 pro Setting

Wir berichten den Median, nicht einen Lauf

Hinweis: Das sind praktikable Einstellungen für diese Demo, nicht feinjustiert für eines der Modelle.

Schritt 1: Voraussetzungen und Setup

Zum Mitmachen brauchst du:

  • Einen Gemini API-Schlüssel aus Google AI Studio

  • Ein Colab-Notebook (oder jede Python-3-Umgebung)

  • google-genai in Version 3.2 oder höher

Die Decisions API hat in Google AI Studio eine kostenlose Stufe zum Prototyping, du kannst sie also vorab ausprobieren. Ich habe diese Demo in Colab ausgeführt, aber jede Python-3-Umgebung funktioniert.

Legen wir mit der Installation los:

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

Hier ist google-genai das Python-SDK von Google für die Gemini API. Es stellt die Methoden client.decisions.create und client.interactions.create bereit, die Anfragen an die Decisions API bzw. Interactions API senden. pandas lädt den Datensatz und organisiert Ergebnisse, matplotlib zeichnet die Grafiken.

Als Nächstes erstellen wir den Client. Die Decisions API benötigt die v1beta-API-Version:

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"

genai.Client() liest den API-Schlüssel aus der Umgebungsvariable GEMINI_API_KEY (in Colab unter „secrets“ gesetzt) und http_options verweist auf die v1beta-API, in der die Decisions API liegt.

Dann laden wir den Banking77-Datensatz und definieren unsere 12 Intents. Jeder Intent bekommt eine Ein-Satz-Beschreibung, die beide Modelle sehen:

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

Der Code lädt den Banking77-Testsplit als CSV, behält nur Zeilen mit unseren 12 Intents, zieht 15 Nachrichten pro Intent mit festem Seed und mischt sie am Ende, damit die Intents durchmischt sind.

So erhalten wir 180 Nachrichten, 15 pro Intent.

Schritt 2: Klassifikation mit der Decisions API

Eine choice-Frage nimmt ein Dictionary, das jede Options-ID auf eine Beschreibung abbildet. Wir übergeben die Nachricht als input und stellen eine Frage mit dem Key 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,
    }

decide_intent() sendet eine Nachricht als input und eine choice-Frage mit unseren 12 Intents als Optionen. Wir messen die Dauer mit time.perf_counter() und lesen Top-Option, Konfidenz, alle Optionswahrscheinlichkeiten und Tokenzahlen aus der Antwort.

Jede Antwort enthält drei Felder:

  • choice: Die Option mit der höchsten Wahrscheinlichkeit

  • probabilities: Eine Wahrscheinlichkeit je Option, die Summe ist 1

  • confidence: Die geschätzte Wahrscheinlichkeit, dass die Top-Antwort korrekt ist

Das usage-Objekt meldet Eingabetokens, und total_output_tokens ist immer 0.

So sah das Ergebnis für die erste Nachricht in unserem Sample aus:

Das Modell verwechselte zwei ähnliche Intents, aber seine Konfidenz von 0,846 signalisiert Unsicherheit. Positiv: Der korrekte Intent card_arrival lag mit fast der gesamten Restwahrscheinlichkeit (rund 0,15) auf Platz zwei. Alle anderen Optionen lagen nahe 0.

Schritt 3: Klassifikation mit Flash-Lite

Für die generative Baseline nutzen wir strukturierten Output mit einem enum derselben 12 Labels, damit Flash-Lite nur ein gültiges Label zurückgeben kann. Zusätzlich bitten wir um eine Konfidenz zwischen 0 und 1 – so holen die meisten Apps einen Konfidenzwert aus einem generativen Modell:

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,
    }

generate_intent() baut einen Prompt mit den 12 Intents und ihren Beschreibungen. Wir rufen Flash-Lite mit response_format auf unser JSON-Schema auf, sodass der Output gültiges JSON mit einem der 12 Labels sein muss. Die Temperatur ist 0 und das Thinking-Level minimal, damit die Antwort stabil und kurz bleibt. Anschließend parsen wir interaction.output_text mit json.loads() und lesen die Tokenzahlen aus interaction.usage.

Ich habe dieselbe Nachricht wie im vorigen Schritt mit Flash-Lite getestet – es machte denselben Fehler, allerdings mit höherer Konfidenz:

Thinking-Tokens sind 0 – minimal hat Flash-Lite also auf das reine Schreiben der Antwort beschränkt. Flash-Lite nutzte weniger Eingabetokens als Decision 1 (277 vs. 337), weil die Decisions API die Optionsbeschreibungen innerhalb der Frage als Input zählt.

Schritt 4: Eine Nachricht pro Anfrage klassifizieren

Jetzt senden wir alle 180 Nachrichten an beide Modelle – je eine pro Anfrage, nach zwei Warmup-Calls:

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"]

Die Schleife schickt jede Nachricht an beide Funktionen und speichert Prediction, Konfidenz, Latenz und Tokenzahlen als Zeile. Daraus entsteht ein DataFrame; die Spalte correct markiert, ob Prediction und wahres Label übereinstimmen.

Hier sind die Ergebnisse:

Metrik

Gemini Decision 1

Gemini 3.5 Flash-Lite

Genauigkeit

84,4%

83,9%

Median-Latenz

325 ms

1.068 ms

p90-Latenz

412 ms

6.483 ms

Langsamste Anfrage

1,0 s

101,6 s

Anfragen > 5 s

0 von 180

33 von 180

Ø Eingabetokens

339

279

Ø Ausgabetokens

0

25

Drei Learnings aus diesen Metriken:

  • Genauigkeit: Beide Modelle waren in etwa gleich genau.
  • Latenz: Decision 1 war im Median rund 3x schneller und deutlich konstanter, während Flash-Lite einen langen Tail langsamer Anfragen hatte.
  • Tokens: Decision 1 nutzte mehr Eingabetokens, weil die Optionsbeschreibungen zählen, generierte aber keine Ausgabetokens.

Hinweis: Unsere Zeiten enthalten den Netzwerkrundtrip aus Colab – dieser Anteil ist umgebungsabhängig.

Schritt 5: Kalibrierung prüfen

Genauigkeit sagt, wie oft ein Modell richtig liegt. Kalibrierung sagt, ob seine Konfidenz aussagekräftig ist. Ein Modell ist gut kalibriert, wenn seine Konfidenz zur Genauigkeit passt – d. h., bei 0,8 sollten in der Gruppe etwa 80% korrekt sein.

Dafür bündeln wir Vorhersagen in 10 Konfidenz-Bins und vergleichen pro Bin die durchschnittliche Konfidenz mit der Accuracy. Die Expected Calibration Error (ECE) ist die gemittelte Lücke, gewichtet nach der Bin-Größe. Je niedriger, desto besser.

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

ece() ordnet jede Vorhersage anhand der Konfidenz einem von 10 Bins zu (0–0,1, 0,1–0,2, ...). Pro Bin berechnet es die Lücke zwischen mittlerer Konfidenz und Accuracy, gewichtet mit dem Anteil der Vorhersagen im Bin, und summiert auf.

So schneiden die beiden Modelle ab:

Metrik

Gemini Decision 1

Gemini 3.5 Flash-Lite

Genauigkeit

84,4%

83,9%

Ø Konfidenz

0,867

0,957

ECE

0,050

0,124

Ø Konfidenz (richtig)

0,901

0,966

Ø Konfidenz (falsch)

0,686

0,912

Abbildung: Reliability-Diagramme für beide Modelle

Die Konfidenz von Decision 1 liegt nah an der tatsächlichen Genauigkeit, ECE = 0,050. Sie ist klar niedriger, wenn das Modell falsch liegt (0,686), als wenn es richtig liegt (0,901).

Flash-Lite ist überkonfident. Es meldet im Schnitt 0,957 bei 83,9% Treffern. Es nutzte nur 9 unterschiedliche Konfidenzwerte über 180 Antworten, 158 davon lagen bei 0,95 oder höher. Selbst die falschen Antworten lagen im Mittel bei 0,912. Die Zahl wirkt wie eine Wahrscheinlichkeit, ist aber eine textlich ausgegebene Eigeneinschätzung.

Kalibrierung zählt, wenn du auf Basis der Konfidenz handelst. Ein gängiges Muster: Antworten oberhalb eines Schwellwerts akzeptieren, den Rest an ein Fallback-Modell oder an Menschen geben:

Schwellwert

Decision 1: Anteil behalten

Decision 1: Genauigkeit (behalten)

Flash-Lite: Anteil behalten

Flash-Lite: Genauigkeit (behalten)

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%

Bei Decision 1 funktioniert ein höherer Schwellwert erwartungsgemäß. Bei 0,9 bleiben 63% der Nachrichten übrig – mit 95,6% Genauigkeit. Bei Flash-Lite bringt der Schwellwert wenig, weil auch viele falsche Antworten hohe Konfidenz haben. Die offiziellen Docs empfehlen, den Schwellwert anhand gelabelter Beispiele aus deinem eigenen Traffic zu setzen.

Schritt 6: 100 Nachrichten in einer Anfrage klassifizieren

Die Decisions API kann bis zu 1.000 Fragen zu einem gemeinsamen Input in einer einzigen Anfrage beantworten. Dafür packen wir N Kundennachrichten in einen Input und stellen je eine Frage pro Nachricht.

Für Decision 1 heißt das: N choice-Fragen mit den Keys m1 bis 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

build_batch() nummeriert die ersten N Nachrichten und fügt sie zu einem gemeinsamen Input zusammen. decide_batch() erstellt je Nachricht eine choice-Frage (Keys m1 bis mN), sendet alles in einer Anfrage und liest je Key eine Antwort aus.

Für Flash-Lite schicken wir denselben gemeinsamen Input mit einem JSON-Schema, das N Felder enthält, jeweils auf 12 Labels beschränkt. Jede N nutzt dieselben Nachrichten für beide Modelle, jedes Setting läuft dreimal.

Fragen pro Anfrage

Decision 1: Median-Latenz

Flash-Lite: Median-Latenz

Decision 1: Eingabetokens

Flash-Lite: Input / Output Tokens

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

Fehlgeschlagen

15.100

Fehlgeschlagen

100

59.095 ms

Fehlgeschlagen

30.309

Fehlgeschlagen

Bis 25 Fragen blieb die Median-Latenz von Decision 1 unter 550 ms. Bei Flash-Lite wuchs sie mit N – von unter 1 s bei 1 bis 5 Fragen auf 2,75 s bei 25 –, da es jede Antwort als Ausgabetokens schreiben muss. Selbst bei 50 Fragen lag der Median von Decision 1 bei 592 ms, auch wenn einer der drei Läufe 70 s dauerte.

Zwei Punkte zum Nachdenken:

  • Flash-Lite scheiterte bei 50 und 100 Fragen: Die „Fehlgeschlagen“-Zeilen sind derselbe 400-Fehler: Das Schema „hat zu viele Zustände für Serving“. Ein Schema mit ≥50 Feldern, je auf 12 Labels beschränkt, übersteigt die API-Grenzen.
  • Decision 1 wurde bei 100 Fragen langsamer: Jede Frage wiederholt alle 12 Optionsbeschreibungen (ca. 300 Tokens je Frage). Die Anfrage kam somit auf 30.309 Tokens, während Googles „flache Latenz“ Kontexte bis etwa 16K Tokens abdeckt.

Schritt 7: Anfragen verschlanken

Naheliegende Frage: Können wir Verlangsamungen und Fehler beheben? Für Decision 1 nutzen wir leere Optionsbeschreibungen (""). Für Flash-Lite bitten wir statt N separater Felder um eine Liste mit N Labels:

# Decision 1: nur Option-IDs, keine Beschreibungen
"criteria": {k: "" for k in LABELS}

# Flash-Lite: ein Listenfeld statt N Feldern
schema = {
    "type": "object",
    "properties": {"intents": {
        "type": "array",
        "items": {"type": "string", "enum": LABELS},
        "minItems": n, "maxItems": n,
    }},
    "required": ["intents"],
}

So lief Decision 1 mit leeren Beschreibungen:

Fragen pro Anfrage

Median-Latenz

Genauigkeit

Eingabetokens

25

357 ms

84,0%

3.995

50

649 ms

78,0%

7.950

100

1.603 ms

83,0%

16.009

Das Weglassen der Beschreibungen halbierte grob die Eingabetokens. Bei 100 Fragen fiel die Anfrage auf etwa 16K Tokens und der Median von 59 s auf 1,6 s. Die Genauigkeit sank bei 25 und 50 Fragen etwas – kurze Beschreibungen sind daher oft der beste Mittelweg, vor allem bei ähnlichen Intents.

Das Listen-Schema half Flash-Lite nicht. Es funktionierte bei 25 Fragen, scheiterte aber weiter bei 50 und 100.

Schritt 8: Kosten vergleichen

Zum Schluss berechnen wir die Kosten aus den von den APIs zurückgemeldeten Tokenzahlen – mit Preisen der Bezahlstufe:

Modell

Preis Input pro 1 Mio. Tokens

Preis Output pro 1 Mio. Tokens

Gemini Decision 1

$0,10

$0

Gemini 3.5 Flash-Lite

$0,30

$2,50 (inkl. 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

cost_per_request() multipliziert die Tokenzahlen mit dem Preis pro 1 Mio. Tokens. Bei Decision 1 zählen nur Eingabetokens. Bei Flash-Lite werden Thinking-Tokens zum Outputpreis berechnet und daher zu den Ausgabetokens addiert.

Hier die Kosten pro 1.000 Anfragen für jedes Setup:

Setup

Gemini Decision 1

Gemini 3.5 Flash-Lite

Flash-Lite / Decision 1

1 Nachricht pro Anfrage

$0,034

$0,147

4,3x

5 Fragen pro Anfrage

$0,155

$0,271

1,7x

10 Fragen pro Anfrage

$0,306

$0,459

1,5x

25 Fragen pro Anfrage

$0,757

$1,088

1,4x

25 Fragen, verschlankte Setups (Schritt 7)

$0,400

$0,831

2,1x

50 Fragen pro Anfrage

$1,510

Fehlgeschlagen

n/v

100 Fragen, leere Beschreibungen

$1,601

Fehlgeschlagen

n/v

Bei einzelnen Nachrichten war Decision 1 4,3x günstiger. Der Abstand schrumpft jedoch, wenn du viele Fragen in eine Anfrage bündelst. Der gemeinsame Input wird in beiden APIs einmal berechnet. Aber jede Decision-1-Frage trägt ihre Instruktion und alle 12 Optionsbeschreibungen, während Flash-Lite die Labelliste nur einmal sieht und pro Antwort kurz schreibt. Bei 25 Fragen nutzte Decision 1 7.570 Eingabetokens gegenüber 710 Input und 350 Output bei Flash-Lite.

Hinweis: Die Decisions API unterstützt kein Context Caching und keine Batch API. Wenn du denselben Input mehrfach sendest, wird er jedes Mal voll berechnet. Hast du viele Fragen zu demselben Input, stelle sie in einer Anfrage – nicht verteilt über mehrere.

Wann welches Vorgehen?

Basierend auf den Läufen passt ein Entscheidungsmodell besonders, wenn:

  • Die Antwort aus einer festen Optionsmenge kommt – etwa Intents, Routen, Tools oder Richtlinienlabels
  • Die Entscheidung im Request-Pfad liegt und alle Nutzenden darauf warten
  • Du auf Basis der Konfidenz handeln willst – z. B. unklare Fälle an Fallback oder Mensch gibst
  • Du viele unabhängige Fragen zu demselben Input in einer Anfrage stellen willst

Ein generatives Modell ist besser, wenn:

  • Du Erklärungen, extrahierte Werte oder Freitext brauchst
  • Die Menge möglicher Antworten offen ist oder sich pro Anfrage ändert
  • Du ohnehin schon einen generativen Anruf auf diesem Input machst und die Klassifikation dort mitgeben kannst

Nutze die Decisions API, wenn du brauchst

Nutze die Interactions API, wenn du brauchst

Ja/Nein-Wahrscheinlichkeiten, eine Option aus einer festen Menge oder eine Bewertung auf einer festen Skala

Generierten Text, Zusammenfassungen oder Erklärungen

Kalibrierte Wahrscheinlichkeiten, die du schwellwerten kannst

Extrahierte Werte oder Objekte nach deinem JSON-Schema

Viele unabhängige Checks über denselben Input in einem Call

Toolaufrufe mit Argumenten

Niedrige Latenz und keine Kosten für Ausgabetokens

Mehrschritt-Reasoning

Fazit

In diesem Tutorial haben wir einen Banking-Intent-Classifier mit Gemini Decision 1 und Gemini 3.5 Flash-Lite gebaut und beide bei Genauigkeit, Latenz, Kalibrierung und Kosten verglichen. Vier zentrale Erkenntnisse:

  • Genauigkeit: Unentschieden. 84,4% für Decision 1 und 83,9% für Flash-Lite – mit identischem Urteil bei 163 von 180 Nachrichten.
  • Decision 1 war schneller und berechenbarer: Median 325 ms vs. 1.068 ms, langsamste Anfrage 1,0 s vs. 101,6 s.
  • Die Konfidenz von Decision 1 war nutzbar: ECE 0,050 vs. 0,124; ein Schwellenwert von 0,9 hob die Genauigkeit der behaltenen Antworten von 84,4% auf 95,6%. Flash-Lites Selbstkonfidenz trennte richtige und falsche Antworten kaum.
  • Kosten und Skalierung hängen von der Fragestellung ab: Decision 1 war bei Einzelanfragen 4,3x günstiger, aber jede Frage zahlt ihre Optionsbeschreibungen mit. Halte den Gesamt-Input unter ca. 16K Tokens und die Beschreibungen kurz.

Diese Ergebnisse stammen aus einer Aufgabe, einem Datensatz und wenigen Läufen in Colab. Sie sind Beobachtungen aus einer Demo – keine allgemeinen Performance-Zusagen.

Aashi Dutt

Autor

Aashi Dutt

Ich bin Google Developers Expertin für ML (Gen AI), dreifache Kaggle-Expertin und Women-Techmakers-Botschafterin mit über drei Jahren Erfahrung in der Tech-Branche. 2020 habe ich ein Health-Tech-Startup mitgegründet und absolviere derzeit einen Master in Informatik an der Georgia Tech mit Schwerpunkt Machine Learning.

FAQs

Worin unterscheidet sich die Decisions API von einer generativen API?

Eine generative API schreibt ihre Antwort Token für Token und berechnet jedes Ausgabetoken. Die Decisions API bewertet in einem Forward-Pass eine feste Menge an Optionen und liefert für jede eine Wahrscheinlichkeit. Es entstehen keine Ausgabetokens – du zahlst nur für den Input.

Ist Gemini Decision 1 genauer als Gemini 3.5 Flash-Lite?

Nicht in unserem Test. Bei 180 Banking-Nachrichten lag die Genauigkeit bei 84,4% für Decision 1 und 83,9% für Flash-Lite. Unterschiede sahen wir bei Latenz, Kalibrierung und Kosten.

Warum nutzt Decision 1 mehr Eingabetokens als Flash-Lite?

Instruktion und Optionsbeschreibungen jeder Frage zählen als Input. Mit 12 beschriebenen Optionen kamen in unserem Test etwa 300 Tokens pro Frage hinzu. Kürzere oder leere Beschreibungen senken das.

Bleibt die Latenz flach, wenn ich mehr Fragen hinzufüge?

In unseren Läufen blieb der Median bis 50 Fragen unter 650 ms. Bei 100 Fragen mit vollen Optionsbeschreibungen erreichte die Anfrage rund 30K Tokens und dauerte 48 bis 59 s. Mit leeren Beschreibungen passten dieselben 100 Fragen in ca. 16K Tokens und dauerten 1,6 s.

Welche Fragetypen unterstützt die Decisions API?

Die Decisions API unterstützt drei Fragetypen: noul für Ja/Nein-Prüfungen, choice zur Auswahl einer Option aus 2 bis 255 und score zur Bewertung entlang einer geordneten Skala. Du kannst alle drei in einer Anfrage mischen.

Themen