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.
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.03Bereitgestellt von
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}Bereitgestellt von
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
...Bereitgestellt von
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.
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.
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"Bereitgestellt von
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))Bereitgestellt von
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:
defdecide_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,}Bereitgestellt von
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"],}defgenerate_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,}Bereitgestellt von
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"]Bereitgestellt von
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.
defece(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.0for b inrange(n_bins):
mask = ids == b
if mask.sum():
total += mask.mean()*abs(conf[mask].mean()- correct[mask].mean())return totalBereitgestellt von
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:
defbuild_batch(n):
msgs = pool.iloc[:n]
shared ="Banking customer messages:\n"+"".join(f"Message {i +1}: {t}\n"for i, t inenumerate(msgs["text"]))return shared,list(msgs["category"])defdecide_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 inrange(n)}
result = client.decisions.create(
model=DECISION_MODEL,input=shared, questions=questions
)
preds =[result.answers[f"m{i +1}"].choice for i inrange(n)]return preds, gold, result.usageBereitgestellt von
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"],}Bereitgestellt von
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)
defcost_per_request(model, input_tokens, output_tokens, thought_tokens):if model =="decision":return input_tokens *0.10/1e6return(input_tokens *0.30+(output_tokens + thought_tokens)*2.50)/1e6Bereitgestellt von
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.
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.
Analyze data smarter with Gemini in Google Sheets. Use AI-powered insights, formula suggestions, and automation to simplify spreadsheets and boost productivity.
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:
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 ausliestEinen 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.
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_cardundexchange_rate. Es gibt für jede eine Wahrscheinlichkeit zurück: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:
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:
Das verändert drei messbare Dinge:
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_arrivalundcard_delivery_estimatepending_card_payment,declined_card_paymentundcard_payment_fee_chargedpending_transfer,transfer_not_received_by_recipientundbalance_not_updated_after_bank_transferlost_or_stolen_card,card_not_working,exchange_rateundtop_up_failedÄhnliche Intents machen die Aufgabe anspruchsvoller – und die Konfidenzwerte spannender.
Wir lassen den Classifier mit beiden Modellen auf zwei Arten laufen:
Das halten wir in beiden Modellen gleichs:
Einstellung
Wert
Begründung
Entscheidungsmodell
gemini-decision-1Das zu testende Modell
Generatives Modell
gemini-3.5-flash-liteKosteneffiziente generative Baseline aus dem Launch-Vergleich
Flash-Lite-Temperatur
0.0
Entfernt Sampling-Rauschen aus der Baseline
Flash-Lite Thinking Level
minimalHält den Vergleich beim Decoding, nicht beim Reasoning
Ausgabeformat
JSON-Schema mit einem
enumder 12 LabelsFlash-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-genaiin Version 3.2 oder höherDie 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:
Hier ist
google-genaidas Python-SDK von Google für die Gemini API. Es stellt die Methodenclient.decisions.createundclient.interactions.createbereit, die Anfragen an die Decisions API bzw. Interactions API senden.pandaslädt den Datensatz und organisiert Ergebnisse,matplotlibzeichnet die Grafiken.Als Nächstes erstellen wir den Client. Die Decisions API benötigt die v1beta-API-Version:
genai.Client()liest den API-Schlüssel aus der UmgebungsvariableGEMINI_API_KEY(in Colab unter „secrets“ gesetzt) undhttp_optionsverweist 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:
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 alsinputund stellen eine Frage mit dem Keyintent:decide_intent()sendet eine Nachricht alsinputund einechoice-Frage mit unseren 12 Intents als Optionen. Wir messen die Dauer mittime.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 Wahrscheinlichkeitprobabilities: Eine Wahrscheinlichkeit je Option, die Summe ist 1confidence: Die geschätzte Wahrscheinlichkeit, dass die Top-Antwort korrekt istDas
usage-Objekt meldet Eingabetokens, undtotal_output_tokensist 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_arrivallag 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
enumderselben 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:generate_intent()baut einen Prompt mit den 12 Intents und ihren Beschreibungen. Wir rufen Flash-Lite mitresponse_formatauf unser JSON-Schema auf, sodass der Output gültiges JSON mit einem der 12 Labels sein muss. Die Temperatur ist0und das Thinking-Levelminimal, damit die Antwort stabil und kurz bleibt. Anschließend parsen wirinteraction.output_textmitjson.loads()und lesen die Tokenzahlen ausinteraction.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 –
minimalhat 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:
Die Schleife schickt jede Nachricht an beide Funktionen und speichert Prediction, Konfidenz, Latenz und Tokenzahlen als Zeile. Daraus entsteht ein DataFrame; die Spalte
correctmarkiert, 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:
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.
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 Keysm1bismN:build_batch()nummeriert die ersten N Nachrichten und fügt sie zu einem gemeinsamen Input zusammen.decide_batch()erstellt je Nachricht einechoice-Frage (Keysm1bismN), 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:
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:
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)
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:
Ein generatives Modell ist besser, wenn:
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:
Diese Ergebnisse stammen aus einer Aufgabe, einem Datensatz und wenigen Läufen in Colab. Sie sind Beobachtungen aus einer Demo – keine allgemeinen Performance-Zusagen.