Ga naar hoofdinhoud

Gemini Decisions API: Google’s nieuwe beslismodel testen op latentie en kosten

Leer hoe Gemini Decision 1 vaste opties scoort zonder tekst te genereren, bouw een intent-classifier voor banken met de Decisions API en vergelijk die met Gemini 3.5 Flash-Lite op nauwkeurigheid, latentie, calibratie en kosten.
· 15 min lezen

Verken met AI

De meeste LLM-apps zitten vol met kleine beslissingen: Welke tool moet de agent aanroepen? Welk model moet deze vraag afhandelen? Overtreedt dit bericht een policy?

Vandaag beantwoorden veel teams deze vragen door een generatief model te vragen het antwoord als tekst te schrijven, en die tekst vervolgens te parsen om een beslissing te nemen.

Google's Gemini Decisions API kiest een andere aanpak. Het gebruikt het Gemini Decision 1-model om in één forward pass een vaste set opties te scoren en geeft een waarschijnlijkheid per optie terug, met nul gefactureerde outputtokens.

In deze tutorial voeren we dezelfde intent-classificatietaak uit op twee setups:

  • Gemini Decision 1 via de Decisions API
  • Gemini 3.5 Flash-Lite via de Interactions API, met gestructureerde JSON-output

We vergelijken ze op nauwkeurigheid, latentie, tokenverbruik, kosten en calibratie, en sturen daarna beide van 1 naar 100 vragen in één request.

Aan het eind van deze tutorial kun je:

  • De Decisions API aanroepen met choice-vragen en de kansen en confidencescores lezen

  • Een generatieve baseline bouwen met de Interactions API en een JSON-schema

  • Latentie, tokenverbruik en kosten voor beide aanpakken meten

  • Controleren of je de confidence van een model kunt vertrouwen, met een reliability-diagram en expected calibration error (ECE)

  • Bepalen wanneer een beslismodel beter bij je app past dan een generatief model

Je kunt de complete code draaien in deze Google Colab.

Beslismodellen vs. generatieve modellen

Voordat we kijken hoe elk werkt, definiëren we de twee termen.

  • Generatief model: Dit model produceert nieuwe content. Je geeft het een prompt en het schrijft een antwoord token voor token. Dat antwoord kan van alles zijn, zoals een antwoord, samenvatting, code of label. Gemini 3.5 Flash-Lite, zoals de meeste LLM’s die we in chatapps gebruiken, is een generatief model.
  • Beslismodel: Een beslismodel kiest uit de opties die jij definieert. Je geeft het een input en een vaste lijst met mogelijke antwoorden, en het vertelt je de waarschijnlijkheid van elke optie zonder een regel tekst te schrijven. Gemini Decision 1 is een beslismodel.

Hier is een voorbeeld. 

Een klant schrijft aan een bank: "Mijn pas is nog niet aangekomen. Wanneer komt die?"

Als je een generatief model vraagt: "Wat wil deze klant?", dan kan het antwoorden:

“De klant wacht op een nieuwe pas en wil weten wanneer die arriveert.”

Dat is een goed antwoord voor een mens. Maar als je app het bericht naar het juiste team moet routeren, moet je code die zin nu omzetten naar een label. Je kunt een label afdwingen met een JSON-schema, maar het model schrijft het nog steeds token voor token.

Als je echter een beslismodel hetzelfde vraagt, geef je eerst de opties mee, zoals card_arrival, lost_or_stolen_card en exchange_rate. Het retourneert een waarschijnlijkheid per optie:

card_arrival         0.91
lost_or_stolen_card  0.06
exchange_rate        0.03

Je code kan dan direct op die waarschijnlijkheid handelen door naar het kaartteam te routeren als card_arrival boven een drempel ligt, en anders naar een mens te sturen. Kort gezegd:

 

Generatief model

Beslismodel

Retourneert

Tekst die het schrijft

Een waarschijnlijkheid voor elke door jou gedefinieerde optie

Mogelijke antwoorden

Open einde

Vaste set

Goed voor

Antwoorden, samenvattingen, uitleg en extractie

Routing, toolselectie, policychecks en beoordeling

In de praktijk gebruiken veel apps één generatief model voor beide taken. Dat testen we in de volgende sectie: of een beslismodel het classificatiegedeelte beter doet dan een generatief model.

Als je een generatief model als classifier gebruikt, schrijft het het antwoord token voor token. Voor een JSON-antwoord zoals het onze ziet de output er tijdens het genereren zo uit:

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

Elk token is een aparte decodiestap, en elk outputtoken wordt gefactureerd. Als je een confidencescore wilt, moet het model dat getal ook schrijven. Dat getal is de eigen gok van het model over zichzelf, geen waarschijnlijkheid gemeten uit zijn internals.

Een beslismodel slaat deze schrijfstap over. Je geeft de opties vooraf mee, en het scoort ze allemaal tegen de input in één forward pass. Het resultaat is een waarschijnlijkheid voor elke optie:

card_arrival            0.12
card_delivery_estimate  0.85
lost_or_stolen_card     0.01
...

Dit verandert drie dingen die je kunt meten:

  • Latentie: Er is geen decodlus, dus de latentie zou niet moeten toenemen met de lengte van het antwoord.
  • Kosten: Er zijn geen outputtokens om te factureren. Je betaalt alleen voor inputtokens, waaronder je vraagtekst en optieomschrijvingen.
  • Confidence: De confidence komt uit de waarschijnlijkheden zelf, dus die zou moeten volgen hoe vaak het model gelijk heeft.

De trade-off is dat je alleen gesloten vragen kunt stellen. Een beslismodel kan zijn antwoord niet uitleggen, geen waarde extraheren of vrije tekst schrijven.

Demo: een intent-classifier voor banken bouwen

In deze demo bouwen we een intent-classifier voor banken. We gebruiken de test-split van Banking77, een publieke dataset met klantberichten gelabeld met 77 intents, en houden 12 intents over die makkelijk met elkaar te verwarren zijn:

  • card_arrival en card_delivery_estimate

  • pending_card_payment, declined_card_payment en card_payment_fee_charged

  • pending_transfer, transfer_not_received_by_recipient en balance_not_updated_after_bank_transfer

  • lost_or_stolen_card, card_not_working, exchange_rate en top_up_failed

Vergelijkbare intents maken de taak lastiger, wat de confidencescores interessanter maakt om te bestuderen.

We draaien de classifier met beide modellen op twee manieren:

  • Eén bericht per request: 180 berichten (15 per intent), één voor één naar elk model gestuurd.
  • Veel vragen per request: N berichten in één gedeelde input, met één vraag per bericht, voor N = 1, 5, 10, 25, 50 en 100.

Hier zijn de instellingen die we voor beide modellen gelijk houdens:

Instelling

Gebruikte waarde

Waarom 

Beslismodel

gemini-decision-1

Het model onder test

Generatief model

gemini-3.5-flash-lite

De kostenefficiënte generatieve baseline die in de launchpost-vergelijking is gebruikt

Flash-Lite-temperatuur

0.0

Verwijdert samplingruis uit de baseline

Flash-Lite denk-niveau

minimal

Houdt de vergelijking bij decoderen, niet redeneren

Outputformaat

JSON-schema met een enum van de 12 labels

Flash-Lite kan alleen een geldig label retourneren

Optieomschrijvingen

Eén korte zin per intent

Beide modellen zien dezelfde labeldefinities

Warmup-calls

2 per model

Houdt het opzetten van de verbinding buiten de metingen

Herhalingen (veel vragen per request)

3 per instelling

We rapporteren de mediaan, niet één enkele run

Let op: Dit zijn werkinstellingen voor deze demo, geen getunede instellingen voor een van beide modellen.

Stap 1: Vereisten en setup

Om mee te doen heb je nodig:

  • Een Gemini API-sleutel van Google AI Studio

  • Een Colab-notebook (of een andere Python 3-omgeving)

  • google-genai versie 3.2 of hoger

De Decisions API heeft een kosteloze laag in Google AI Studio voor prototyping, dus je kunt het proberen voordat je betaalt. Ik draaide deze demo in Colab, maar gebruik gerust elke Python 3-omgeving. 

Laten we beginnen met het installeren van de packages:

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

Hier is google-genai Google’s Python-SDK voor de Gemini API. Het geeft ons de methoden client.decisions.create en client.interactions.create, die requests sturen naar respectievelijk de Decisions API en de Interactions API. We gebruiken pandas om de dataset te laden en resultaten te organiseren, en matplotlib om figuren te plotten.

Vervolgens maken we de client aan. De Decisions API heeft de v1beta API-versie nodig:

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"

Hier leest genai.Client() de API-sleutel uit de GEMINI_API_KEY die onder secrets in Colab of als omgevingsvariabele is gezet, en http_options wijst naar de v1beta-API, waar de Decisions API draait. 

Daarna laden we de Banking77-dataset en definiëren we onze 12 intents. Elke intent krijgt een beschrijving van één zin die beide modellen te zien krijgen:

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

De bovenstaande code downloadt de Banking77 test-split als CSV en houdt alleen de rijen over die gelabeld zijn met een van onze 12 intents. Vervolgens worden er 15 berichten per intent bemonsterd met een vaste random seed, zodat je bij elke run hetzelfde sample krijgt. De laatste .sample(frac=1) schudt de rijen zodat de intents gemixt zijn.

Dit levert 180 berichten op, 15 per intent.

Stap 2: Classificeren met de Decisions API

Een choice-vraag neemt een dictionary die elke optie-ID mapt naar een beschrijving. We geven het bericht mee als input en stellen één vraag, met sleutel 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,
    }

De functie decide_intent() stuurt één bericht als input en één choice-vraag met onze 12 intents als opties. We timen de call met time.perf_counter(), en lezen vervolgens de topkeuze, confidence, alle optiewaarschijnlijkheden en tokencounts uit de response.

Elk antwoord bevat drie velden:

  • choice: De optie met de hoogste waarschijnlijkheid

  • probabilities: Eén waarschijnlijkheid per optie, somt op tot 1

  • confidence: De geschatte kans dat het topantwoord correct is

Het usage-object rapporteert inputtokens, en total_output_tokens is altijd 0.

Hier is het resultaat voor het eerste bericht in ons sample:

Het model verwarde twee vergelijkbare intents, maar de confidence van 0,846 toont enige onzekerheid. Het goede nieuws is dat de juiste intent, card_arrival, tweede werd met bijna alle resterende waarschijnlijkheid (ongeveer 0,15). Alle andere opties zaten rond nul.

Stap 3: Classificeren met Flash-Lite

Voor de generatieve baseline gebruiken we gestructureerde output met een enum van dezelfde 12 labels, zodat Flash-Lite alleen een geldig label kan retourneren. We vragen ook om een confidence tussen 0 en 1, wat is hoe de meeste apps een confidencescore uit een generatief model halen:

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

De functie generate_intent() bouwt een prompt met de 12 intents en hun beschrijvingen. Hij roept Flash-Lite aan met response_format ingesteld op ons JSON-schema, zodat de output geldige JSON moet zijn met een van de 12 labels. De temperatuur staat op 0 met minimal denk-niveau om het antwoord stabiel en kort te houden. We parsen daarna interaction.output_text met json.loads() en lezen de tokencounts uit interaction.usage.

Ik testte hetzelfde bericht als in de vorige stap met Flash-Lite, en het maakte dezelfde fout met hogere confidence:

Denktokens zijn 0, wat bevestigt dat minimal denken Flash-Lite tot alleen het schrijven van het antwoord beperkte. Flash-Lite gebruikte minder inputtokens dan Decision 1 (277 vs 337) omdat de Decisions API de optieomschrijvingen binnen de vraag als input meetelt.

Stap 4: Eén bericht per request classificeren

Laten we nu alle 180 berichten naar beide modellen sturen, één request per keer, na twee warmup-calls per model:

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

Deze loop stuurt elk bericht naar beide functies en slaat de voorspelling, confidence, latentie en tokencounts op als één rij. We zetten de rijen om in een DataFrame en voegen een kolom correct toe die markeert of elke voorspelling overeenkomt met het ware label.

Hier zijn de resultaten:

Metriek

Gemini Decision 1

Gemini 3.5 Flash-Lite

Nauwkeurigheid

84,4%

83,9%

Mediaanlatentie

325 ms

1.068 ms

p90-latentie

412 ms

6.483 ms

Traagste request

1,0 s

101,6 s

Requests boven 5 s

0 van 180

33 van 180

Gemiddelde inputtokens

339

279

Gemiddelde outputtokens

0

25

Hier zijn drie dingen die we leerden van deze metrics:

  • Nauwkeurigheid: Beide modellen waren ongeveer even nauwkeurig.
  • Latentie: Decision 1 was ongeveer 3x sneller op de mediaan en veel consistenter, terwijl Flash-Lite een lange staart van trage requests had.
  • Tokens: Decision 1 gebruikte meer inputtokens omdat de optieomschrijvingen meetellen als input, maar genereerde geen outputtokens.

Let op: Onze timing omvat de netwerk-roundtrip vanuit Colab, dus behandel dat verschil als setup-afhankelijk.

Stap 5: Calibratie controleren

Nauwkeurigheid vertelt hoe vaak een model gelijk heeft, maar calibratie vertelt of zijn confidence iets betekent of niet. Een model is goed gecalibreerd wanneer zijn confidence overeenkomt met zijn nauwkeurigheid; als het bijvoorbeeld 0,8 zegt bij een groep antwoorden, moet ongeveer 80% daarvan kloppen.

Om dit te meten, groeperen we voorspellingen in 10 confidence-bins en vergelijken we de gemiddelde confidence van elke bin met de nauwkeurigheid. Expected calibration error (ECE) is het gemiddelde verschil, gewogen naar hoeveel voorspellingen in elke bin vallen. Lager is beter.

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

De functie ece() plaatst elke voorspelling in een van de 10 bins op basis van zijn confidence (0 tot 0,1, 0,1 tot 0,2, enz.). Voor elke bin neemt hij het verschil tussen gemiddelde confidence en nauwkeurigheid, weegt dat met het aandeel voorspellingen in die bin en telt de resultaten op.

Zo compareren de twee modellen:

Metriek

Gemini Decision 1

Gemini 3.5 Flash-Lite

Nauwkeurigheid

84,4%

83,9%

Gemiddelde confidence

0,867

0,957

ECE

0,050

0,124

Gemiddelde confidence bij goed

0,901

0,966

Gemiddelde confidence bij fout

0,686

0,912

Figuur: Reliability-diagrammen voor beide modellen

De confidence van Decision 1 ligt dicht bij zijn nauwkeurigheid, met een ECE van 0,050. Hij is ook duidelijk lager wanneer het model fout zit (0,686) dan wanneer het goed zit (0,901).

Flash-Lite is overconfident. Het rapporteert gemiddeld 0,957 terwijl het 83,9% van de tijd gelijk heeft. Het gebruikte slechts 9 verschillende confidencewaarden over 180 antwoorden, en 158 daarvan waren 0,95 of hoger. Zelfs de foute antwoorden hadden gemiddeld 0,912. Het getal lijkt op een waarschijnlijkheid, maar het is de eigen schatting van het model, geschreven als tekst.

Calibratie is belangrijk wanneer je op de score handelt. Een veelvoorkomend patroon is om antwoorden boven een drempel te accepteren en de rest door te sturen naar een fallbackmodel of een mens:

Drempel

Decision 1: aandeel behouden

Decision 1: nauwkeurigheid op behouden

Flash-Lite: aandeel behouden

Flash-Lite: nauwkeurigheid op behouden

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%

Met Decision 1 werkt een hogere drempel zoals verwacht. Bij 0,9 houdt het 63% van de berichten over met 95,6% nauwkeurigheid. Bij Flash-Lite helpt de drempel nauwelijks, omdat de meeste foute antwoorden ook een hoge confidence hebben. De officiële docs raden aan een drempel te kiezen op basis van gelabelde voorbeelden van je eigen verkeer.

Stap 6: 100 berichten in één request classificeren

De Decisions API kan tot 1.000 vragen over één gedeelde input in een enkel request beantwoorden. Om dit te testen plaatsen we N klantberichten in één input en stellen één vraag per bericht.

Voor Decision 1 betekent dat N choice-vragen met sleutels m1 t/m 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

Hier nummerert de functie build_batch() de eerste N berichten en voegt ze samen tot één gedeelde input. Vervolgens maakt decide_batch() één choice-vraag per bericht met sleutels m1 t/m mN, stuurt ze allemaal in één request en leest één antwoord per sleutel terug.

Voor Flash-Lite sturen we dezelfde gedeelde input met een JSON-schema dat N velden heeft, elk beperkt tot 12 labels. Elk N gebruikt dezelfde berichten voor beide modellen, en elke instelling draait drie keer.

Vragen per request

Decision 1: mediaanlatentie

Flash-Lite: mediaanlatentie

Decision 1: inputtokens

Flash-Lite: input / outputtokens

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

Mislukt

15.100

Mislukt

100

59.095 ms

Mislukt

30.309

Mislukt

Tot 25 vragen bleef de mediaanlatentie van Decision 1 onder 550 ms. De mediaan van Flash-Lite groeide met N, van onder 1 s bij 1 tot 5 vragen naar 2,75 s bij 25, omdat het elk antwoord als outputtokens moet schrijven. Zelfs bij 50 vragen was de mediaan van Decision 1 592 ms, al duurde een van de drie runs 70 s.

Hier zijn twee punten om te overwegen:

  • Flash-Lite faalde bij 50 en 100 vragen: De "Mislukt"-rijen in de tabel hierboven zijn allemaal dezelfde 400-fout. Die geeft aan dat het schema "te veel toestanden voor serving" heeft. Een schema met 50 of meer velden, elk beperkt tot 12 labels, is meer dan de API accepteert.
  • Decision 1 vertraagde bij 100 vragen: Elke vraag herhaalt alle 12 optieomschrijvingen, ongeveer 300 tokens per vraag, dus het request kwam uit op 30.309 tokens, terwijl Google’s vlakke-latentieclaim geldt voor contexten tot 16K tokens.

Stap 7: Requests trimmen

Nu dringt zich een voor de hand liggende vraag op: kunnen we de vertraging en de fouten oplossen? Voor Decision 1 gebruiken we lege optieomschrijvingen (""). Voor Flash-Lite vragen we om één lijst van N labels in plaats van N losse velden:

# Decision 1: alleen optie-ID's, geen omschrijvingen
"criteria": {k: "" for k in LABELS}

# Flash-Lite: één lijstveld in plaats van N velden
schema = {
    "type": "object",
    "properties": {"intents": {
        "type": "array",
        "items": {"type": "string", "enum": LABELS},
        "minItems": n, "maxItems": n,
    }},
    "required": ["intents"],
}

Zo deed Decision 1 het met lege omschrijvingen:

Vragen per request

Mediaanlatentie

Nauwkeurigheid

Inputtokens

25

357 ms

84,0%

3.995

50

649 ms

78,0%

7.950

100

1.603 ms

83,0%

16.009

Het schrappen van de omschrijvingen halveerde grofweg de inputtokens. Bij 100 vragen kwam het request uit op circa 16K tokens en daalde de mediaanlatentie van 59 s naar 1,6 s. De nauwkeurigheid daalde iets bij 25 en 50 vragen, dus korte omschrijvingen zijn een beter midden dan geen, zeker bij vergelijkbare intents.

Het lijstschema hielp het Flash-Lite-model niet. Het werkte bij 25 vragen, maar faalde nog steeds bij 50 en 100.

Stap 8: Kosten vergelijken

Tot slot berekenen we de kosten op basis van de tokencounts die elke API teruggeeft, met prijzen uit de betaalde laag:

Model

Prijs input per 1M tokens

Prijs output per 1M tokens

Gemini Decision 1

$0,10

$0

Gemini 3.5 Flash-Lite

$0,30

$2,50 (inclusief denktokens)

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

De functie cost_per_request() vermenigvuldigt elke tokencount met de prijs per 1M tokens. Voor Decision 1 tellen alleen inputtokens mee. Voor Flash-Lite worden denktokens tegen de outputprijs gefactureerd, dus tellen we die op bij de outputtokens.

Hier zijn de kosten per 1.000 requests voor elke setup:

Setup

Gemini Decision 1

Gemini 3.5 Flash-Lite

Flash-Lite / Decision 1

1 bericht per request

$0,034

$0,147

4,3x

5 vragen per request

$0,155

$0,271

1,7x

10 vragen per request

$0,306

$0,459

1,5x

25 vragen per request

$0,757

$1,088

1,4x

25 vragen, getrimde setups (Stap 7)

$0,400

$0,831

2,1x

50 vragen per request

$1,510

Mislukt

n.v.t.

100 vragen, lege omschrijvingen

$1,601

Mislukt

n.v.t.

Bij enkele berichten was Decision 1 4,3x goedkoper, maar het verschil krimpt naarmate je meer vragen in één request bundelt. De gedeelde input wordt in beide API’s één keer gefactureerd. Maar elke Decision 1-vraag draagt zijn eigen instructie en alle 12 optieomschrijvingen mee, terwijl Flash-Lite de labellijst maar één keer ziet en per antwoord een korte output betaalt. Bij 25 vragen gebruikte Decision 1 7.570 inputtokens tegenover 710 input en 350 outputtokens voor Flash-Lite.

Let op: De Decisions API ondersteunt geen contextcaching of de Batch API. Als je dezelfde input in meerdere requests stuurt, wordt die elke keer volledig gefactureerd. Dus als je veel vragen over dezelfde input hebt, stel ze in één request in plaats van ze over meerdere calls te verspreiden.

Wanneer welke aanpak gebruiken

Gebaseerd op bovenstaande runs past een beslismodel beter wanneer:

  • Het antwoord uit een vaste set opties komt, zoals intents, routes, tools of policylabels
  • De beslissing in het requestpad zit, waar elke gebruiker erop wacht
  • Je op confidence wilt handelen, bijvoorbeeld door onduidelijke gevallen door te sturen naar een fallback of een mens
  • Je veel onafhankelijke vragen over dezelfde input in één request moet stellen

Een generatief model past nog steeds beter wanneer:

  • Je een uitleg, een geëxtraheerde waarde of vrije tekst nodig hebt
  • De set mogelijke antwoorden open is of per request verandert
  • Je al een generatieve call op die input deed en de classificatie daaraan kunt toevoegen

Gebruik de Decisions API wanneer je nodig hebt

Gebruik de Interactions API wanneer je nodig hebt

Een ja/nee-kans, één optie uit een vaste set, of een rating op een vaste schaal

Gegenereerde tekst, samenvattingen of uitleg

Gecalibreerde waarschijnlijkheden die je kunt thresholden

Gëxtraheerde waarden of objecten die jouw JSON-schema volgen

Veel onafhankelijke checks over dezelfde input in één call

Toolcalls met argumenten

Lage latentie en nul outputtokenkosten

Meertrapsredenering

Slotgedachten

In deze tutorial bouwden we een intent-classifier voor banken met Gemini Decision 1 en Gemini 3.5 Flash-Lite, en berekenden we nauwkeurigheid, latentie, calibratie en kosten om de twee modellen te vergelijken. Vier takeaways uit de tutorial:

  • Nauwkeurigheid was gelijkspel: 84,4% voor Decision 1 en 83,9% voor Flash-Lite, met hetzelfde oordeel op 163 van de 180 berichten.
  • Decision 1 was sneller en voorspelbaarder: De mediaanlatentie was 325 ms tegenover 1.068 ms, en de traagste request duurde 1,0 s tegenover 101,6 s.
  • De confidence van Decision 1 was bruikbaar: De ECE was 0,050 tegenover 0,124, en het verhogen van de drempel naar 0,9 tilde de nauwkeurigheid op behouden antwoorden van 84,4% naar 95,6%. De zelfgerapporteerde confidence van Flash-Lite onderscheidde juiste en foute antwoorden nauwelijks.
  • Kosten en schalen hangen af van hoe je de vragen schrijft: Decision 1 was 4,3x goedkoper bij enkele berichten, maar elke vraag betaalt voor zijn optieomschrijvingen. Houd dus de totale input onder circa 16K tokens en houd optieomschrijvingen kort.

Deze resultaten komen uit één taak, één dataset en een klein aantal runs vanuit een Colab-notebook. Behandel ze als observaties uit een demo, niet als algemene prestatieclaims. 

Aashi Dutt

Auteur

Aashi Dutt

Ik ben een Google Developers Expert in ML (Gen AI), een Kaggle 3x Expert en een Women Techmakers Ambassador met meer dan 3 jaar ervaring in tech. In 2020 heb ik een healthtech-startup mee opgericht en ik volg een master computer science aan Georgia Tech, met als specialisatie machine learning.

FAQs

Wat is het verschil tussen de Decisions API en een generatieve API?

Een generatieve API schrijft zijn antwoord token voor token en factureert elk outputtoken. De Decisions API scoort een vaste set opties in één forward pass en retourneert een waarschijnlijkheid voor elke optie. Er worden geen outputtokens gegenereerd, dus je betaalt alleen voor input.

Is Gemini Decision 1 nauwkeuriger dan Gemini 3.5 Flash-Lite?

Niet in onze test. Op 180 bankberichten was de nauwkeurigheid 84,4% voor Decision 1 en 83,9% voor Flash-Lite. De verschillen die we maten zaten in latentie, calibratie en kosten.

Waarom gebruikt Decision 1 meer inputtokens dan Flash-Lite?

De instructie van elke vraag en de optieomschrijvingen tellen mee als input. Met 12 beschreven opties leverde dat in onze test ongeveer 300 tokens per vraag op. Korte of lege optieomschrijvingen verlagen dit.

Blijft de latentie vlak als ik meer vragen toevoeg?

In onze runs bleef de mediaan onder 650 ms tot en met 50 vragen. Bij 100 vragen met volledige optieomschrijvingen bereikte het request ongeveer 30K tokens en duurde 48 tot 59 s. Met lege omschrijvingen pasten dezelfde 100 vragen in circa 16K tokens en duurde het 1,6 s.

Welke vraagtypes ondersteunt de Decisions API?

De Decisions API ondersteunt drie vraagtypes, waaronder noul voor ja/nee-checks, choice voor het kiezen van één optie uit 2 tot 255, en score voor beoordelen op een geordende rubric. Je kunt alle drie in één request combineren.

Onderwerpen

Gerelateerd