Gemini Decision: question types, limits and pricing

Evaluate agents
HoneyHive Engineering

Gemini Decision (gemini-decision-1) is Google's model for the Decisions API. It answers yes/no, choice and rubric questions with calibrated probabilities, not text.

Gemini Decision (gemini-decision-1) is a Google model built for the Decisions API. It evaluates typed questions over text, images, video, audio and PDFs in a single prefill pass and returns calibrated outcome probabilities with zero output tokens. Instead of writing an answer, it gives your code a yes probability, a chosen option or a rubric score, each with a confidence value to branch on. Google released the model and the API on November 11, 2026.

Google’s guide makes the case for it: when code needs a judgment to branch on, generating and parsing text adds latency and brittle parsing logic. For LLM work, that makes it a candidate for routing, policy checks and rubric scoring, though it cannot explain an answer or generate text.

How a request works

Each call sends one shared input and a map of named questions, and gets back one typed answer per question. Every question runs against the shared input in one forward pass, questions can’t see each other, and Google says latency stays nearly flat as you add questions. Adding or removing a question doesn’t change the other answers, and the model never sees your question keys, so the full question goes in instructions.

The quickstart needs SDK 3.2 or later and the v1beta API version:

from google import genai

client = genai.Client(http_options={"api_version": "v1beta"})

result = client.decisions.create(
    model="gemini-decision-1",
    input="The blue mug I ordered on Monday arrived cracked on Wednesday.",
    questions={
        "is_damaged": {
            "type": "noul",
            "instructions": "Did the item arrive damaged?",
        },
    },
)
answer = result.answers["is_damaged"]
print(f"P(yes)={answer.noul:.2f} confidence={answer.confidence:.2f}")

The response holds answers and a usage block whose total_output_tokens is 0.

Question types

The API has three question types. The yes/no type is called noul in requests and responses.

Type (type) What you send in criteria What comes back Size limit
Yes/no (noul) Optional true_description and false_description to define what yes and no mean noul, the probability of yes from 0.01 to 0.99, and confidence Two outcomes
Single-select (choice) A map of option IDs to descriptions of when each applies choice (the top option), probabilities for every option summing to 1, and confidence 2 to 255 options
Rubric rating (score) An array of level descriptions ordered from lowest to highest, indexed from 0 score (the probability-weighted average of level indices), probabilities, legend and confidence 2 to 255 levels, with 2 to 10 recommended

Confidence is the estimated probability that the top answer is right: the top outcome’s probability, or max(noul, 1 - noul) for a yes/no question. You can mix types in one request.

A few details change how you read the answers:

  • A yes/no probability never goes above 0.99, so a threshold above 0.99 never matches.
  • A choice question always spreads probability across your options, even when none fits. Google suggests a confidence threshold, a separate yes/no scope check, or a catch-all such as other. Option keys are sorted alphabetically before evaluation, so a key like none_of_the_above does not land last.
  • A score can fall between levels, and different distributions can give the same score, so check the per-level probabilities too. Dividing by the highest level index puts scales of different lengths on 0 to 1.
  • Score levels should form a linear scale. Because the score averages level indices, values like 1, 10, 100 and 1000 skew it. The same advice to keep levels distinct applies to any evaluation rubric.

Limits and what it does not support

Limit Value
Questions per request 1 to 1,000, bounded by the context window
Context window 262,144 tokens shared by the input and all questions
Output token limit 0
Input types Text, image, video, audio and PDF input; question instructions are text only
Inline media Base64 bytes up to 100 MB per request, or 50 MB for PDFs; external URLs up to 15 MB each
Question key 1 to 64 ASCII characters matching [A-Za-z0-9_-]+
API surface Gemini Developer API (v1beta) only

The model card marks text generation, structured outputs, function calling, thinking, code execution, search grounding, URL context, caching, the Batch API, the Live API, and Flex and Priority inference as not supported. The API also doesn’t accept YouTube URLs, gs:// URIs and conversation history, thought or tool-call blocks, so multi-turn context has to be serialized as text. A request that trips the input safety filters returns HTTP 400 with an error code in place of answers.

Pricing and rate limits

Prices below are Google’s list in November 2026.

Free tier Paid tier (per 1M tokens)
Input (text, image, video, audio, PDF) Free of charge $0.10
Output Not applicable, 0 output tokens Not applicable, 0 output tokens
Context caching Not available Not available
Used to improve Google’s products Yes No

Each request bills the shared input tokens once, regardless of question count, and each question adds tokens for its own instructions, criteria and formatting. Across requests the same input counts in full each time, because there is no context caching.

Google lists these standard rate limits in November 2026. They apply per project, not per API key.

Usage tier Requests per minute Tokens per minute Requests per day
Free 200 50,000 10,000
Tier 1 1,500 1,000,000 50,000
Tier 2 5,000 4,000,000 Unlimited
Tier 3 15,000 10,000,000 Unlimited

Google notes that these limits are not guaranteed and that actual capacity may vary.

When to use it for evaluation and routing

Google’s list of uses maps closely onto LLM application work: routing a request to a model, queue, agent or tool; checking inputs and outputs against many policy rules at once; deciding which tools an agent needs or whether to escalate or stop; and filtering, scoring or ranking candidate results against a rubric.

Job How Gemini Decision fits
Model routing A choice question with one option per model or queue, and a confidence threshold that sends unsure cases to a default or a person, as the guide’s example does with human_review
Policy and guardrail checks One noul question per rule in a single request, since shared input is billed once and up to 1,000 questions fit in one call
Rubric scoring of outputs A score question against your rubric. Google says a complex rubric works in one question when its criteria are explicit, or you can split independent checks into separate questions and combine the answers in code
Ranking candidates Sort by score, which the guide describes as a way to rank inputs or filter candidate results against a rubric threshold

Where it does not fit:

  • When you need a rationale. The model cannot write one. Google sends explanations, summaries, multi-step reasoning and tool calls to the generative Interactions API. A generative LLM-as-a-judge that explains each grade is still the tool when people need to read why an output failed, for example during error analysis.
  • When the decision depends on numbers or dates. Google advises comparing numbers, dates and durations in code and passing the result in the input.
  • When the text being judged can argue its case. The guide warns that user-supplied text can argue for its own classification, and recommends explicit criteria, adversarial tests and a human or second check on high-stakes actions. A model output you are grading is input like any other, so the same care applies.
  • When you need open-ended or schema output. Extracted values that follow your own JSON schema belong to structured outputs, which this model does not support.

Check the calibration yourself

In scikit-learn’s definition, among samples given a probability close to 0.8, approximately 80% should actually belong to the positive class. Guo and colleagues found that modern neural networks are often poorly calibrated, which is why the claim is worth testing on your own data.

Google does not publish a calibration or accuracy benchmark for gemini-decision-1 on its model, guide, pricing or rate limit pages. Its own advice is to set thresholds using labeled examples from your own traffic, weighing the cost of a false positive against a false negative. That means a labeled set from human evaluation, with inter-annotator agreement checked first, and a calibration curve (also called a reliability diagram) of the model’s probabilities against those labels. Re-check after you change a question’s wording or criteria.

Using Gemini Decision with HoneyHive

HoneyHive’s server-side Python evaluators run in a sandbox with no network access, so they cannot call the Decisions API. The place for it is a client-side evaluator, which runs in your own code: either a function passed to evaluate() that receives outputs, inputs and ground_truth and returns a score for offline experiments, or a metric attached to production traces with enrich_span() or enrich_session(). That covers both sides of online vs offline evaluation. For the human labels that calibration needs, annotation queues collect expert labels on traced outputs and turn them into ground truth for evaluators.

FAQ

What is gemini-decision-1?

It is the model code for Gemini Decision, the only model behind Google's Decisions API. It takes text, images, video, audio and PDFs and returns calibrated probabilities for yes/no, choice and score questions, with an output token limit of 0.

How much does Gemini Decision cost?

In November 2026, Google lists a paid-tier input price of $0.10 per 1M tokens for every input type, no output price because there are no output tokens, and a free tier. Shared input is billed once per request however many questions you ask; each question adds its own instruction and criteria tokens.

Can Gemini Decision explain its answers?

No. Text generation is not supported, and Google points you to the Interactions API when you need generated text, summaries or explanations. If you need a written rationale for each grade, use a generative LLM judge.

Is the Decisions API the same as structured output?

No. Structured output is for extracted values that follow your own JSON schema. The Decisions API generates zero text tokens and returns typed answers with probabilities, so it fits closed questions with a fixed set of outcomes.

Share