Gemini Decision 1 takes your input plus a list of options and sends back the odds on each one. No essay, no chat reply, just a probability and a confidence score.
Google shipped it on November 11, 2026. Ask it "is this invoice overdue," "which support queue should this go to," or "how severe is this bug," and it returns a probability for each, plus a confidence score, in a single pass.
I went through Google's launch blog, the Decisions API docs, the model page, the live pricing and rate-limit pages, and the independent Artificial Analysis leaderboard, then pulled the real numbers into one place. Here's what Gemini Decision 1 actually is, what it costs, what the benchmarks say once you separate Google's figures from an outside lab's, and whether it replaces a normal Gemini model. (Short version on that last one: no.)
| Detail | Value |
|---|---|
| What it is | A specialized multimodal decision model (it scores options, it doesn't write text) |
| Released | November 11, 2026 |
| Model ID | gemini-decision-1 |
| Runs on | The new Decisions API, in the Gemini Developer API (v1beta) |
| Price | $0.10 per 1M input tokens, $0 for output, free tier for prototyping |
| Context window | 262,144 tokens (Google also rounds this to "256K") |
| Throughput | Up to 1,000 independent questions per request |
| Inputs | Text, image, audio, video, and PDF |
| Latency | 150 to 250 ms end-to-end (Google's figure, for contexts up to 16K tokens) |
| Not yet on | Google Cloud / Vertex AI (support is "coming soon") |
Gemini Decision 1 is a specialized multimodal model that scores a fixed set of options and returns calibrated probabilities, instead of generating an answer in words. Google released it on November 11, 2026, and it runs on a new endpoint called the Gemini Decisions API.
In plain English, think of it like this. A normal language model is the brain that writes you the essay. A decision model is the judge who just gives you the verdict and tells you how sure they are.
You send one shared input (text, an image, an audio clip, a video, or a PDF) along with up to 1,000 questions. The model scores every question against that input in a single forward pass and sends back a value plus a confidence score from 0 to 1 for each one. Your code reads that score and decides whether to act automatically or kick the case to a human.
Because every answer comes with a calibrated probability, you can wire Gemini Decision 1 into the spots where you used to need a brittle classifier or a slow generative call: routing a ticket, checking a policy, grading a photo, or picking which model handles a request.
A decision model scores your candidate options directly, with no sentence for a human to read in between, which is why it runs fast and bills zero output tokens.
Gemini Decision 1 answers three kinds of questions, and you can mix all three in one request:
| Question type | What it returns | Reach for it when |
|---|---|---|
| Yes/no (noul) | A probability from 0.01 to 0.99, plus confidence | You need a true/false check, like "did this item arrive damaged" |
| Choice (choice) | The top pick from 2 to 255 options, with a probability for each | You're routing or selecting, like "which department handles this" |
| Score (score) | A weighted score across 2 to 255 ordered levels (2 to 10 recommended), with per-level odds | You're grading against a rubric, like "how severe is this issue" |
A few things make this different from asking a general-purpose model like Gemini 3.8 Flash to "answer in JSON."
Questions can't see each other. Each one runs against the shared input on its own, so adding a tenth question doesn't change the answer to the first. You compose the results with ordinary if statements in your own code.
Your shared input is billed once. Whether you ask 1 question or 500, the input tokens count a single time. Each extra question only adds its own short instruction and criteria.
Latency stays nearly flat. Google reports the model holds steady from 1 to 100 questions per request, so batching your checks doesn't blow up your response time.
Gemini Decision 1 costs $0.10 per 1M input tokens, and output is free because there are no output tokens. That price covers text, image, video, audio, and PDF input alike. There's also a free tier you can use in Google AI Studio for prototyping.
A couple of details worth knowing before you build on it:
Because the shared input is billed once and there are no output charges, the cost model rewards packing many questions into one call. You also skip the usual add-ons: no separate audio transcription fee, no OCR charge, no variable thinking-token bill.
To get started, you grab an API key in Google AI Studio and call the model through the Gemini Developer API (v1beta). You'll need the google-genai SDK, version 3.2 or later, though a REST endpoint and a Decisions Playground in AI Studio work too. Outside support is rolling out across OpenRouter, LangChain, Vercel, LiteLLM, Pydantic AI, Pipecat, LiveKit, and OpenCode.
One caveat if you live in Google Cloud: the Decisions API is on the Developer API today, and Google lists Vertex support as "coming soon," so it isn't there yet. For how the economics compare with the rest of the Gemini price list or with Vertex AI pricing, those breakdowns are worth a look.
Your quota depends on your usage tier, and it's tracked three ways at once: requests per minute (RPM), input tokens per minute (TPM), and requests per day (RPD).
| Usage tier | RPM | TPM | RPD |
|---|---|---|---|
| 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 |
The free tier already gives you 10,000 requests a day, which is plenty for testing. Moving to Tier 1 (set up billing) jumps you to a million input tokens a minute. Limits apply per project, not per API key, and the daily counter resets at midnight Pacific.
Google says Gemini Decision 1 leads its benchmark suite with the lowest calibration error. The table below is straight from the launch, so read every number as Google's own, measured as Top-1 accuracy unless noted, with refusals and safety blocks scored as wrong.
| Benchmark | Gemini Decision 1 | TypeSafe Jev 1.14 | GPT-6 Luna | Gemini 3.5 Flash-Lite |
|---|---|---|---|---|
| JevBench (public split) | 92.2 | 90.0 | 90.9 | 86.6 |
| Amazon ESCI (Macro-F1) | 58.7 | 56.7 | 54.7 | 47.2 |
| New Yorker Caption (text-only) | 79.7 | 72.0 | 68.4 | 73.7 |
| Mind2Web (multimodal) | 86.2 | 86.8 | 81.8 | 78.0 |
| PubMedQA | 79.8 | 78.2 | 74.4 | 77.6 |
| Global-MMLU-Lite (non-English) | 86.0 | 85.0 | 79.6 | 78.8 |
| When2Call | 79.9 | 82.0 | 70.4 | 60.9 |
| MMAU (audio) | 71.8 | not reported | not reported | 67.7 |
| Video-MME (no subtitles) | 69.1 | not reported | not reported | 63.3 |
| Top-1 ECE, 7 shared evals (lower is better) | 0.0250 | 0.0494 | 0.0721 | 0.2104 |
| Total price, 7 shared evals | $0.88 | $0.68 | $0.93 | $4.14 |
It's a strong showing, and the calibration numbers (that ECE row) are genuinely good. Two caveats come with a vendor's own table.
Gemini Decision 1 doesn't win everything. TypeSafe's Jev 1.14 edges it on Mind2Web and When2Call, and Jev comes in cheaper on Google's own cost row ($0.68 versus $0.88).
The headline savings claim is a narrow one. Google's "nearly 5x cheaper" line compares Gemini Decision 1 at $0.88 against Gemini 3.5 Flash-Lite at $4.14 on that shared suite, not against every rival on the list.
{{templates}}
Artificial Analysis, an outside lab, tells a different story. Its Decision Index, version 2.1, scores Gemini Decision 1 at 66, which lands it mid-pack, around 9th out of 18 decision models. It shares that 66 with TypeSafe's Jev 1.14 and Elephant 9B, and sits ahead of OpenAI's GPT-6 Luna decision model at 60, while the leaders sit in the low 70s.
The calibration story holds up (Gemini Decision 1 posts a low Brier score, so when it's confident, it tends to be right). On raw accuracy it comes out average. On Artificial Analysis's cost-per-task measure it's one of the pricier models on the index, at $345 per 1M tasks, fourth-highest of the 18.
Why the gap between this and Google's table? The two measure different things. Artificial Analysis builds its index from a separate set of evaluations, and only one benchmark (When2Call) overlaps with Google's launch suite. So "leads across the suite" and "mid-pack on the index" can both be true at once, depending on which tests you run. Treat the Index figure as a snapshot that will shift as the lab adds models and updates scores.
Gemini Decision 1 is narrow by design, and a few of those limits will bite if you assume it works like a normal Gemini model.
It comes down to what you want back from the model.
Choose Gemini Decision 1 if you:
Skip it if you:
The cost math is what makes it tempting. Say you send one shared input of about 2,000 tokens and ask 50 yes/no questions about it. You pay for that input once, each question tacks on only its own short instructions, and output is free. The whole call lands at a few hundredths of a cent. Run the same 50 checks as 50 separate generative prompts and you'd pay for the input 50 times over, plus output tokens on every one.
A decision model is a developer building block. It's the kind of thing you drop into a pipeline to route a ticket or grade an input, and it does that one job well.
Plenty of people reading about Gemini Decision 1 would rather hand off the busywork than build the pipeline themselves. That's the job Lindy does: it's an AI teammate for the whole company. @mention it in a Slack channel for team answers, or DM it as your own assistant for inbox and calendar, and it's closer to a real hire than another app to configure.
With Lindy, teams can:
Say a customer with an open invoice emails support. Tell Lindy "route anything from an account with an overdue invoice to billing," and it labels the thread, moves it to the billing queue, and checks with you before it sends a reply.
Lindy is model-agnostic, so you can keep exploring the model landscape (including Gemini 4 Argon and Gemini 4 Carbon) while it quietly gets your daily tasks done.
Try Lindy free and tell it what you need in plain English.
{{cta}}
Gemini Decision 1 is Google's specialized multimodal decision model, released November 11, 2026. It scores closed-set options across text, images, audio, video, and PDFs and returns calibrated probabilities instead of generating text.
Gemini Decision 1 costs $0.10 per 1M input tokens, with $0 for output because it produces zero output tokens. There's a free tier for prototyping, and your shared input is billed once per request no matter how many questions you ask.
The context window is 262,144 tokens. "256K" is Google's rounded way of describing the same limit, which covers the shared input and all of your questions combined.
One request handles up to 1,000 independent questions over a single shared input. Each question is scored on its own and can't see the others, so adding questions doesn't change the existing answers.
No, Gemini Decision 1 is not on Google Cloud or Vertex AI yet. It runs on the Gemini Developer API (v1beta) today, and Google lists Vertex support as "coming soon."
No, Gemini Decision 1 does not replace Gemini Flash. It doesn't generate text, so it works alongside the general-purpose Gemini models and handles decisions while they handle writing and chat.
Gemini Decision 1 and OpenAI's GPT-6 Luna both run decision APIs, and Google's table gives Gemini the edge on every benchmark where both are reported, while Artificial Analysis scores Gemini ahead of GPT-6 Luna on its independent index. For the full head-to-head, see our Gemini Decision 1 vs GPT-6 Luna breakdown.
