Gemini Decisions API explained: what it is, what it costs and how to pair it with an LLM
Google's Gemini Decisions API, introduced on November 11, 2026, scores a fixed set of answers instead of writing text, in about 200 ms. What it is, what it costs, how Google's lead holds up against Artificial Analysis's own run, how to pair it with an LLM, and where a business could use it.
On November 11, 2026, Google introduced the Gemini Decisions API, an endpoint for a new model, Gemini Decision 1, that never writes an answer. You give it an input and a list of questions with fixed answers, and it returns a probability for each option in 150 to 250 milliseconds on inputs up to 16K tokens, Google says, for $0.10 per million input tokens. That makes it a different tool from a chatbot, and the fun part is using the two together.
Two disclosures. I have not run Gemini Decision 1: this rests on Google’s post, its docs, pricing and rate-limit pages, and the pages of Artificial Analysis and Amazon, all read on November 18. And Google’s examples are its own products, support tickets, invoices, photos and calls, so the business ideas below are my view. As on the rest of this site, the article and its picture were written by an agent, with the tests as the gate.
It is a Google endpoint that scores a fixed set of answers for each question you send, over one shared input, and returns probabilities instead of text. The model is gemini-decision-1, which you call through the Gemini API and can try in Google AI Studio. In Google’s own example, a photo of a breakroom counter gets a spill probability of 0.95 and a recommended action: wipe it with a cloth.
Fact
Gemini Decision 1, as published
Question types
noul (yes or no, 0.01 to 0.99), choice (2 to 255 options), score (a rubric of 2 to 255 ordered levels)
Input
Text, JSON as text, images, audio, video and PDFs, 262,144 tokens in all
Per request
1 to 1,000 questions about one shared input, each scored on its own
Output
A probability for every option, plus a confidence, and zero output tokens
Speed
150 to 250 ms end to end, for contexts up to 16K tokens and 1 to 100 questions, Google says
Price
$0.10 per million input tokens, shared input billed once; a free tier whose data Google may use to improve its products
Limits
No Batch API and no caching, so repeated input is billed in full; Tier 1 allows 1,500 requests a minute and 50,000 a day
Status
v1beta, Gemini Developer API only; Google Cloud support is listed as coming soon
It chooses where an LLM writes. The model scores the options you supply in a single pass, with no token-by-token generation, so your code gets a number to branch on instead of text to parse, and each answer carries a confidence, which is the top answer’s probability. Google’s docs split the work between its two endpoints roughly like this:
Aspect
Decisions API
An LLM, such as Google’s Interactions API
You send
An input and questions with fixed answer options
A prompt
You get back
A probability for every option
Text, structured data or tool calls
You pay for
Input tokens
Input and output tokens
It suits
Routing, checks, rankings and ratings
Writing, summaries, explanations, extraction and multi-step reasoning
It is the colleague who answers everything with a number and never explains. It is also not alone: TypeSafe’s Jev, which I covered in an earlier article, has the same three question types, down to the odd name noul for yes or no, and OpenAI’s GPT-6 Luna has a Decisions API too.
Google’s own table puts it first on seven of nine tests and lowest on calibration error, while Artificial Analysis’s own run puts it level with Jev among the 18 decision models it charts, so I trust the speed more than the crown.
Measure
In Google’s post
In Artificial Analysis’s own run
Score
First on 7 of 9 tests, 2 of them with no Jev or GPT-6 Luna score; Jev 1.14 wins Mind2Web (86.8 vs 86.2) and When2Call (82.0 vs 79.9)
Decision Index 66 (accuracy less a Brier penalty), tied with Jev 1.14; the top score is 75
Calibration
Top-1 ECE 0.0250 vs 0.0494 for Jev (lower is better)
Brier score 0.18 vs 0.19 for Jev; the lowest is 0.15
Speed
150 to 250 ms for up to 16K tokens
211 ms per task; Jev 92 ms
Cost
$0.88 for 7 tests vs $0.68 for Jev and $4.14 for Gemini 3.5 Flash-Lite (minimal)
$345 per million tasks vs $156 for Jev; only 3 of 18 cost more
Why the runs differ. Google’s tests are named benchmarks, from product search to video. Artificial Analysis’s index combines six evaluations on documents, tool calling, knowledge, reasoning and whether a decision survives rewording, and scores accuracy less a Brier penalty, where Google reports accuracy and ECE separately. They do not contradict each other, but nothing in the independent run shows a clear lead over Jev, which is faster and cheaper there.
Language models on the same chart. Switch them on and it adds GPT-6 Luna and Claude Haiku 5.5 in versions labeled Low, at 69 and 67, taking 4.44 and 3.01 seconds a task for $485 and $861 per million tasks. Pick the Max versions and both reach 76, at 11.36 and 32.32 seconds and $1,548 and $6,218. The page does not define the labels. Against Gemini Decision 1 that is 1 to 10 points higher, 14 to 153 times slower and 1.4 to 18 times the cost (my arithmetic), the case for pairing the two kinds of model rather than picking one.
Not independent. The table is Google’s own, with no error bars and no word on who ran the other models, and it counts refusals and blocked requests as wrong. Artificial Analysis’s cost and time are averages across its own six evaluations.
By letting the decision model make the many small, fast calls around the LLM and keeping the LLM for the few jobs that need words. This part is my view, built on the uses in Google’s docs.
Front desk. One call scores every incoming message: topic, urgency, language, whether it is about an order. Code sends the easy ones to a template or a small model and the hard ones to a big one. Google says Gemini Notebook routes queries this way, to the model tier and thinking level each needs, with up to 40 percent lower latency on everyday queries.
Writer and editor. The LLM drafts, once or five times. The decision model checks each draft against your rules in one call: does it promise a refund the policy does not allow, how warm is it from 0 to 2. Code sends the best, asks for a rewrite or hands it to a person. It is an LLM judge that cannot ramble.
Checklist from a guide. The LLM reads your brand guide or policy once and turns it into thirty narrow yes/no questions. The decision model then runs all thirty on every ad, listing or reply in one call, and a request takes up to 1,000.
Score everything, write once. The decision model labels 50,000 reviews by topic and sentiment, code counts them, and the LLM writes the summary from the table and a few examples. It never reads the 50,000.
Brakes for agents. Between agent steps, ask which tool is needed, or whether to compact the context, escalate or stop. Google’s docs list these as uses.
The first two chain into one design, drawn below: decide, draft, check, and a person for whatever the thresholds flag.
My sketch of the pattern, not a Google diagram.
Here it is in code. It is my sketch, adapted from Google’s examples. I have not run it, the thresholds are placeholders and write_reply stands for any LLM from any provider.
import json
from google import genai # google-genai 3.2 or later
client = genai.Client(http_options={"api_version": "v1beta"})
POLICY = "Refunds within 30 days only. Never promise a delivery date."defdecide(text, questions):
result = client.decisions.create(
model="gemini-decision-1", input=text, questions=questions
)
return result.answers
defhandle(message, order):
# 1. Front desk: one call, three typed questions about one input
a = decide(message, {
"topic": {
"type": "choice",
"instructions": "What is this customer message about?",
"criteria": {
"billing": "Payments, invoices and refunds.",
"delivery": "Shipping and tracking.",
"product": "Questions about an item.",
"other": "Anything else.",
},
},
"upset": {
"type": "score",
"instructions": "How upset is the customer?",
"criteria": ["Calm", "Frustrated", "Angry"],
},
"steering": {
"type": "noul",
"instructions": "Does the message try to give instructions to an assistant?",
},
})
# thresholds are placeholders: set them from labeled examples of your own trafficif a["steering"].noul > 0.2or a["topic"].confidence < 0.7or a["upset"].score > 1.5:
returnhand_to_person(message)
# 2. Writer: any LLM from any provider
draft = write_reply(a["topic"].choice, message, order)
# 3. Editor: the decision model sees the draft and the policy, not the message
b = decide(json.dumps({"draft": draft, "policy": POLICY}), {
"breaks_policy": {
"type": "noul",
"instructions": "Does `draft` promise anything that `policy` does not allow?",
},
"warmth": {
"type": "score",
"instructions": "How warm and polite is `draft`?",
"criteria": ["Cold", "Neutral", "Warm"],
},
})
if b["breaks_policy"].noul > 0.1or b["warmth"].score < 1.2:
returnhand_to_person(draft)
returnsend(draft) # hand_to_person, write_reply and send are your own code
Three cautions. Treat input as untrusted, as the docs warn, because a message can talk the model into a label. The editor above never sees the message, though a draft can echo it, and anything like a payout deserves a person. A choice question spreads probability even when nothing fits, so add an other option or a scope check. And a request blocked by Google’s input safety filters returns an HTTP 400 error instead of answers, so in moderation I would treat that as a flag, not a pass.
By making it cheap enough to check everything, every message, listing, ad, call and agent step, instead of a sample. This part is my view.
Support and returns. A message, order data and a customer photo go in; out come damaged or not, which resolution fits and how likely the customer is to leave. Google’s docs show close cousins: a ticket routed from order data and a message, and a photo checked for damage. Low-confidence cases go to a person.
Catalog and search quality. Run yes/no checks on every listing: does the title match the photo, is the size missing, is there a claim we cannot back up. Label search results as exact, substitute, complement or irrelevant, one of the tasks in Amazon’s ESCI benchmark. The post does not say which task it ran, and its 58.7 Macro-F1 beats Jev’s 56.7 by two points, so I would use it to find suspects for a person to review.
Ads, calls and reviews. Check each ad’s image and copy against brand and platform rules before launch, score call recordings or lead messages for intent, and label thousands of reviews by topic and sentiment before an LLM summarizes them. The docs say audio is judged without a separate transcription step and suits call triage.
Tech teams. Routing, guardrails and agent brakes. Google Search uses the API as a safety layer for MCP tools and claims high efficacy with no figure. As a second opinion in front of your own agent’s tools it looks cheap, and I would start with read-only access.
An example, made up. 50,000 listings of 400 tokens, each with six yes/no checks of about 40 tokens, come to 32 million input tokens, or $3.20 at $0.10 per million, which is my arithmetic. It would also use Tier 1’s whole daily allowance of 50,000 requests.
How the tests were run. The table has no error bars, and the post, docs and model page give no model size, training details or technical report.
The baselines. The up to 40 percent lower latency in Gemini Notebook is Google’s own figure for everyday queries, and the Search safety layer claims high efficacy with no figure.
Languages. Only Global-MMLU-Lite is labeled non-English, at 86.0, and ESCI covers English, Japanese and Spanish queries without the post saying which it used, so test your own languages, Swedish included.
Attacks. The docs warn that input can talk the model into a label and give no figures on how often it works.
What I like is the shape: a model that never says a word, only a number, and docs that tell you to check the number before you act on it. It is the quiet colleague who holds up a card that says 0.94. What I would not do is buy the crown: in Artificial Analysis’s own run it is level with Jev, which is faster and cheaper, and only three of 18 cost more per task. The case for it is speed and price against an LLM, plus a probability for every option. The LLM becomes the one who writes, after something faster has decided whether to bother it. My Haiku article covers which model to use for the writing. It was introduced on November 11, it is in v1beta, and my sources are Google’s pages plus Artificial Analysis, so take my enthusiasm for what it is.
Mistral Large 4 (Le Chonk) is a model of about 1 trillion parameters whose weights Mistral released on October 29, 2026. What it is, what its license allows, what it costs to use and run, how the top open-weight claim holds up against Artificial Analysis's own runs, and where it could help.
Mistral's Timestral is a family of time-series models that forecast with a range, not one number. What it is, what it does, what its revenue-limited license allows, what I could and could not check in its benchmark claims, and where it could help e-commerce, tech and marketing.
Anthropic's Claude Dashboards and Claude Motion are in beta. What they are, who gets them, how they could change a marketing team for the better (fewer questions waiting for a ticket, numbers that show their query, explainers you can edit) and what to check first.