Gemini Decision vs. Plain LLM Classification: What's the Difference and Which to Use

Short answer

Google released Gemini Decision (model ID gemini-decision-1) and the matching Decisions API on November 11, 2026. It is not another, larger language model. It is a model that only judges and never writes an answer: you send one input plus up to 1,000 questions, and it returns a probability and confidence for each question in a single pass, producing no output tokens at all.

The trade-off is that it only judges. It cannot reason. Ask it why a ticket was classified as a refund and it has nothing to say. Ask it to extract, then classify, then verify in three steps and it also can't. So it is not a cheaper replacement for a general model. It takes one specific class of work off the general model's hands.

Official price: $0.10 per million input tokens. Output is not billed.

gemini-decision-1 is not yet available on Moyi API. It uses a separate endpoint, /v1beta/decisions, so it is not a matter of changing the model name on our existing API. This post is about how to decide whether you need it and how the two approaches differ.

What Gemini Decision actually does

From the official documentation (November 11, 2026):

Three question types:

• Yes/no: returns a calibrated probability from 0.01 to 0.99, plus a confidence score.
• Single-select: 2 to 255 options; returns the top option, per-option probabilities and confidence.
• Rubric rating: 2 to 255 ordered levels; returns the probability-weighted expected score, per-level probabilities and confidence.

The calibrated probability is one of the biggest practical differences. When a general model says it is "90% confident," that is usually just phrasing and does not correspond to a real hit rate. A calibrated probability can be used as a threshold directly, e.g. "route anything below 0.7 to a human."

What LLM classification looks like today

The standard approach: write a prompt, require the model to emit a structured verdict against a JSON schema.

from openai import OpenAI
import json

client = OpenAI(base_url="https://api.moyi-api.com/v1", api_key="your Moyi API key")

schema = {
    "type": "object",
    "properties": {
        "is_damaged": {"type": "boolean"},
        "category": {"type": "string", "enum": ["shipping", "refund", "product", "other"]},
        "reason": {"type": "string"},
    },
    "required": ["is_damaged", "category", "reason"],
}

resp = client.chat.completions.create(
    model="gemini-4-argon",
    messages=[{
        "role": "user",
        "content": "Classify this support message: the blue mug I ordered Monday arrived cracked on Wednesday.",
    }],
    response_format={"type": "json_schema", "json_schema": {"name": "ticket", "schema": schema}},
)
print(json.loads(resp.choices[0].message.content))

This works, and it is flexible: it can emit a reason, run several judgments in one call, and decide on its own to extract entities before classifying. But it carries three structural costs:

1. Every question generates output tokens. Ten questions means ten outputs; a thousand questions means a thousand. Billed at output rates, so cost scales with question count.
2. The probabilities are not calibrated. "I'm 90% confident" usually cannot be used as a threshold without running your own labeled set first, or simply dropping probabilities and reading only the label.
3. Latency grows with question count. Each additional question adds generation time, which becomes obvious across batches of thousands.

Side by side

So which one should you use

Decide by the nature of the work, not by which model is newer.

Where a general LLM wins

• Reviews that need a stated reason. Risk, content moderation, support tickets: the human reviewer needs to know why. Decision returns a probability, not an explanation.
• Multi-step tasks. Read a PDF, extract the amount, check it against a limit, then pick an approval path. That chain is exactly what Decision does not do.
• Cases that need a clarifying turn. The user was vague, and you need to follow up before classifying.
• Classification that feeds a response. The label triggers generated text, e.g. "classified as refund → write refund instructions."

Where Gemini Decision wins

• Batch policy checks. One contract, invoice or conversation checked against 30 compliance rules, each a yes/no question. A general model needs 30 requests and pays for 30 outputs; Decision needs one request and pays for the input once.
• Scoring candidates against a rubric. Ranking 200 résumés on five dimensions, or rating a batch of replies on a four-level quality scale. The score question returns the probability-weighted expected score, no manual arithmetic.
• Low-latency classification of live media. Streams, calls, video frames: tens of milliseconds with no generation delay. Zero output tokens is decisive here.
• High-volume classification with a hard threshold. Hundreds of thousands of requests a day, routed by a calibrated probability below 0.8, without a human reading each one.

Google's own use-case list confirms the split: request routing, checking one input against many policy rules at once, scoring candidates against a rubric, tool selection, and low-latency classification of live media. What those five have in common is that the verdict itself is the deliverable — no prose needed.

Google is also explicit about what it is not for: multi-step reasoning. That is a design choice, not an unfinished feature.

A practical way to decide

Take the classification task you already have and answer three questions:

1. Does each question need a written answer? Yes → general model. No → keep going.
2. How many questions per input? One or two → a general model is fine; no reason to adopt a new endpoint. Dozens to hundreds → Decision's cost advantage starts to matter.
3. Will you use the probability as a threshold? Yes → calibrated probabilities are usable as-is. No → the calibration advantage goes unused.

Only when all three point to Decision is it worth integrating a new endpoint.

FAQ

Is Gemini Decision a version of Gemini 4? No. gemini-decision-1 is its own model ID built for the Decisions API, and it cannot be called through :generateContent.

Can it replace Gemini 4 Carbon? No. Carbon does reasoning and generation; Decision only judges. They solve entirely different problems.

How does it return a result with zero output tokens? The answer comes from a probability distribution computed during a single prefill pass rather than token-by-token generation. Hence probabilities, no text.

When will it be on Moyi API? Not yet. It needs the new /v1beta/decisions endpoint, not just a model-name change. Once it is available it will appear on the pricing page.

Is repeated input billed again? Yes. There is no context caching, so identical input across requests is billed in full each time. Either ask all your questions in one request or deduplicate on your side.

Related reading

• Gemini 4 Carbon API: also a new Google model, but built for reasoning and generation
• Gemini 4 Argon API: the first Gemini 4 model; structured-output examples live here
• Qwen 3.8 Flash vs. Max for ticket extraction: a hands-on example of choosing a classification model by cost and accuracy