![Gemini Decision 1: 1,000 Questions, $0.10 a Million [2026]](https://shattered.io/wp-content/uploads/2026/11/gemini-decision-1-decisions-api-1000-questions-0-10-per-million-2026-gen.webp)
Google put a different kind of model in developers’ hands on November 11, 2026. Gemini Decision 1, served through the new Gemini Decisions API, answers closed-set questions with probabilities and confidence scores instead of writing text token by token, according to Google’s announcement. BigGo Finance and MLQ.ai both reported the launch the same day.
The pitch is narrow on purpose. Google describes the API as built for “fast, closed-set decisions,” and the price reflects that: $0.10 per 1 million input tokens, with zero output tokens billed. It follows the company’s broader model rollout, which we covered in our look at Gemini 4 Carbon’s intro pricing and uneven availability.
This analysis walks through what Google confirmed, what it left out, and why a model that refuses to write prose might matter more to production teams than another chatbot upgrade. Every spec below comes from Google’s announcement. Where the announcement is silent, this article says so instead of guessing.
Don't miss new tech stories on Google
Add Shattered once in the Google app and our stories show up in your news suggestions.
What Google Announced on November 11 for Gemini Decision 1 #
Google introduced the Gemini Decisions API on November 11, 2026, and named the model behind it Gemini Decision 1, with the model identifier gemini-decision-1. Developers reach it through the Gemini API in Google AI Studio. The announcement does not tie the launch to a separate consumer product, and it does not describe a waitlist.
The core idea is simple. Most large language models generate an answer one token at a time. That works for essays and code, but it is a clumsy way to ask whether an invoice matches a purchase order or whether a support ticket is urgent. Gemini Decision 1 skips the generation step and returns a decision with a probability attached.
A single request can carry up to 1,000 independent questions, per Google. Inputs can be text, images, audio, video, or PDFs, up to 256K tokens. Latency, reported as 150 to 250 milliseconds end to end, is short enough to sit inside a live user flow rather than a batch job.
One caution on framing. Headlines have called this a “low-cost model,” and the price is certainly low. But “low-cost model” is outlet shorthand, not an official product designation in Google’s announcement. Google calls it a decision model behind a dedicated API, and this article uses that language.
How Gemini Decision 1 Works: Closed-Set Decisions, Not Generated Text #
“Closed-set” is the phrase that explains the product. A closed-set question has a fixed list of valid answers: yes or no, one option from a menu, or a score on a defined rubric. The model never has to invent an answer. It only has to rank the allowed ones.
That distinction changes the economics. A generative model pays for every output token it writes, and those tokens add latency because each one waits for the last. A decision model reads the input once and emits numbers. Google’s announcement says the model handles closed-set decisions instead of generating answer text token by token, and the billing model follows from that: no output tokens, no output charge.
The output also differs in kind. Instead of a paragraph that sounds confident whether or not it is right, the response carries probabilities and confidence scores. A downstream system can act on a 0.97 differently than on a 0.55. It can auto-approve the first and route the second to a person.
Developers have long approximated this by prompting a chat model to reply with a single word and then parsing the result. It works, but it carries cost and delay the task never needed. A purpose-built endpoint turns that workaround into a supported feature with a stable shape. Whether the probabilities Google returns are well calibrated is a separate question, and the announcement does not settle it.
The Three Decision Types: Yes/No, Choice, and Rubric Scoring #
Google lists three question types: yes/no, choice, and rubric-scoring. Each maps to a familiar chore in production software, and each has a different failure profile.
Yes/no questions are the simplest. Does this image contain a visible license plate? Does this contract clause mention auto-renewal? The model returns a probability for each side. Binary checks like these power moderation queues, compliance screens, and data-quality gates.
Choice questions ask the model to pick from a list. Which department should handle this ticket? Which of five product categories fits this photo? Routing and tagging make up a huge share of everyday AI work, and a ranked list with confidence scores gives engineers a clean threshold to tune.
Rubric-scoring questions grade an input against defined criteria. Think of scoring a support reply for politeness, grading an essay against a checklist, or rating a product listing for completeness. Teams currently build this with a large model acting as judge, which is slow and costly at volume. Google’s announcement does not publish accuracy figures for any of the three types, so teams will need to measure agreement with human labels themselves.
Gemini Decision 1 Specs at a Glance #
The table below collects every figure Google confirmed. Items not in the announcement are deliberately absent.
| Attribute | Confirmed detail |
|---|---|
| Company | |
| Product | Gemini Decisions API |
| Model | Gemini Decision 1 ( gemini-decision-1 ) |
| Announced | November 11, 2026 |
| Availability | Gemini API in Google AI Studio |
| Function | Closed-set decisions, no token-by-token answer text |
| Decision types | Yes/no, choice, rubric scoring |
| Questions per request | Up to 1,000 independent questions |
| Input formats | Text, images, audio, video, PDFs |
| Input limit | Up to 256K tokens |
| Output | Probabilities and confidence scores |
| Reported latency | 150 to 250 milliseconds end to end |
| Price | $0.10 per 1 million input tokens, zero output tokens billed |
Two entries deserve a second look. The 1,000-question ceiling is per request, so a high-volume app will still send many requests. And the 256K-token limit is the only context figure Google stated. Anything larger floating around the web is unconfirmed.
Pricing: $0.10 per Million Input Tokens and Zero Output Billing #
Google set the price of Gemini Decision 1 at $0.10 per 1 million input tokens, and it bills no output tokens at all. For a decision workload, that removes the cost line that usually dominates. Chat models charge more for output than input, and output is where a verbose model burns money.
The price sits in familiar territory for small, fast models. Our earlier coverage of Meta’s Muse Ember agent model showed the same input rate becoming a reference point for agent workloads. The difference here is the missing output meter. A comparison of API rates, like our breakdown of DeepSeek and Mistral pricing, has to treat a zero-output model as a separate category.
Worked cost examples
The figures below are illustrative arithmetic from Google’s published rate, not Google-supplied examples. They assume input tokens are the only charge, as the announcement states.
| Input per request | Cost per request | Cost per 1,000 requests | Output charge |
|---|---|---|---|
| 2,000 tokens | $0.0002 | $0.20 | $0 |
| 32,000 tokens | $0.0032 | $3.20 | $0 |
| 128,000 tokens | $0.0128 | $12.80 | $0 |
| 256,000 tokens (stated limit) | $0.0256 | $25.60 | $0 |
Even at the full 256K-token limit, one request costs about two and a half cents. A team screening 10,000 short documents of 2,000 tokens each would pay roughly $2.00 in input charges. How the 1,000 questions in a request share that input, and whether they are billed once or separately, is a detail developers should confirm in the documentation before budgeting.
Latency: What 150 to 250 Milliseconds End to End Really Means #
Google reports 150 to 250 milliseconds end to end. That is a vendor figure, and the announcement as cited does not break out the conditions behind it, such as input size, region, or question count. Treat it as a design target until independent tests land.
Still, the range matters for product design. A response inside a quarter second feels instant to a person. That opens placements a generative call rarely suits: gating a form submission, flagging a message as it posts, or choosing which template to render before the page paints. Slower generative models usually get pushed to background queues for exactly this reason.
The speed comes from the architecture rather than from magic. Writing a 200-word answer means producing hundreds of tokens in sequence, and each one adds time. Emitting a handful of probabilities removes that loop. The saving grows with task volume, which is why Google pairs the latency claim with a batch ceiling of 1,000 questions per request.
Teams should still test the tail. Averages hide the slow requests that break a user experience, and the announcement offers no percentile data. A prudent rollout measures the 95th and 99th percentile on real traffic before wiring the endpoint into anything a customer waits on.
Multimodal Inputs and the 256K-Token Ceiling #
Gemini Decision 1 accepts text, images, audio, video, and PDFs, up to 256K tokens of input. That breadth is the quiet strength of the launch. Classic classifiers are usually built for one modality. A team that wants to judge both a PDF contract and a recorded call has traditionally trained or bought two systems.
The 256K-token limit gives real room. A long PDF, a transcript of a meeting, or a stack of product images can fit in one request. Google has not published how images, audio, or video convert into tokens for this model, so developers cannot yet estimate the cost of a one-hour video by arithmetic alone. Running a sample and reading the usage metadata is the safe route.
Mixed-media decisions open new uses. A retailer could ask whether a product photo matches its written description. A support team could ask whether a recorded call contains a refund request. An insurer could ask whether a claim PDF includes a signed form. Each is a closed-set question with a clear answer space, and each previously needed either a custom model or an expensive generative call.
The announcement does not say how accuracy varies by modality. Audio and video questions often prove harder than text ones for any model. Until Google or independent testers publish per-modality results, treat the multimodal claim as capability, not performance.
Why Google Built a Decision Model: Historical Context #
Gemini Decision 1 arrives after several years in which generative models absorbed nearly every machine learning task. Sentiment tagging, spam filtering, intent routing, and content moderation once belonged to small trained classifiers. As chat models improved, teams swapped those classifiers for prompts because a prompt was faster to write than a labeled dataset.
That convenience carried a bill. Using a large generative model to answer yes or no pays for a capability the task never uses. Engineers noticed, and many built workarounds: asking for one-word replies, capping output length, reading token probabilities where an API exposed them. These patches show real demand for a cheaper, steadier tool.
The agent boom raised the stakes. An autonomous agent makes dozens of small judgment calls per task. Should it call this tool? Is the last result good enough? Does the user’s message look like an attack? If each call runs through a full generative model, cost and delay stack up fast. Our test of prompt injection detectors shows how much agent safety already depends on quick yes/no judgments.
Seen that way, a dedicated decision endpoint is less a surprise than an overdue unbundling. Google is splitting one general capability into a specialized product, with its own price, its own output format, and its own latency target. Whether rivals follow is the question worth watching.
Gemini Decision 1 vs Generative Models and Classic Classifiers #
Gemini Decision 1 competes with two existing approaches: a general chat model prompted to answer in a fixed format, and a purpose-trained classifier. The table compares them on structure, using only properties that follow from how each approach works and from Google’s published specs.
| Dimension | Gemini Decision 1 | Chat model with structured output | Trained classifier |
|---|---|---|---|
| Output | Probabilities and confidence scores | Generated text, often parsed | Label with a score |
| Billing basis | Input tokens only ($0.10 per 1M) | Input and output tokens, typically | Your own compute and upkeep |
| Setup | Write the questions | Write a prompt and a parser | Collect labels, train, retrain |
| Input types | Text, images, audio, video, PDFs | Varies by model | Usually one modality |
| Batching | Up to 1,000 questions per request | Depends on prompt design | Depends on your serving stack |
| Calibration | Not independently confirmed | Varies, often weak | Measurable on your own data |
| Open-ended answers | Not supported | Supported | Not supported |
No approach wins everywhere. A trained classifier still beats a hosted model for teams with large labeled datasets, strict latency control, or data that cannot leave their network. The build-versus-rent logic is similar to the one in our comparison of self-hosted LLMs against hosted APIs.
A chat model remains the better choice when the answer needs explanation. Gemini Decision 1 will not tell a customer why a claim was denied. It will tell a pipeline how likely the claim is to match a rule. Many production systems need exactly that and nothing more.
Market Impact: Who Gains and Who Feels Pressure #
The first beneficiaries are teams with high-volume, low-stakes judgment calls: moderation, routing, tagging, and quality scoring. For them, a zero-output price and sub-second latency change the math on tasks that were too expensive to automate with a full model. Google’s pricing also puts pressure on any vendor selling narrow classification services at a markup.
Pressure falls on three groups. Small API startups that wrap a chat model to deliver moderation or scoring now face a first-party rival from the model maker. Labs that sell only generative endpoints will be asked why they bill output tokens for yes/no work. And teams running homegrown classifiers must decide whether upkeep still beats a rented endpoint at this price.
For Google, the strategic angle is the Gemini API itself. A cheap, narrow endpoint pulls developers into AI Studio and the wider platform, where they may later buy larger models. It is a familiar play: price the workhorse low and win the account. Readers tracking the broader field can follow the AI and machine learning section for how rivals respond.
Market sizing is where honesty matters. Neither Google nor the outlets covering the launch published adoption numbers, revenue figures, or customer names for Gemini Decision 1 in the material this article relies on. Any claim about its share of the classification market would be invention, so none appears here.
What Is Confirmed and What Is Not #
Confirmed by Google’s announcement: the product name, the model name and identifier, the November 11, 2026 date, availability in Google AI Studio through the Gemini API, the three decision types, the 1,000-question ceiling, the five input formats, the 256K-token limit, the probability and confidence output, the 150 to 250 millisecond latency, and the $0.10 input price with no output billing.
Not confirmed, and so not stated as fact here: any claim of benchmark leadership, any claim of the “lowest calibration error,” free-tier limits, a context window beyond the official 256K tokens, and per-task performance figures. Some pages circulating online lean on such claims. The cited announcement does not back them.
The distinction matters because calibration is the whole point of a decision model. A probability is only useful if a 90 percent score is right about nine times in ten. Google says the model returns confidence scores, but a stated feature is not a measured result. Independent evaluation on real tasks is the missing piece.
Also unconfirmed in the sources reviewed: rate limits, regional availability beyond AI Studio access, service-level commitments, and any data-retention terms specific to this model. Teams in regulated industries should read the terms before sending customer data through the endpoint.
Where Developers Should Test Gemini Decision 1 First #
The best early tests share three traits: a fixed answer space, a human-labeled sample to check against, and a clear cost of being wrong. Start where a mistake is cheap and reversible, then widen.
Triage and routing
Support tickets, email, and form submissions need sorting before anyone reads them. A choice question with a confidence threshold lets a system auto-route the clear cases and send the uncertain ones to a person. Measure how often the model’s top pick matches your current routing, and how that rate changes as you tighten the threshold.
Screening and scoring
Yes/no and rubric questions suit first-pass screening, such as flagging documents that need legal review or scoring listings for completeness. Keep humans in the loop for anything consequential. The model’s job is to shrink the pile, not to make the final call. Run the same sample through your current method and compare agreement before shifting any traffic.
A simple evaluation recipe works for all of these. Pull 500 to 1,000 labeled examples, send them in batches, and plot confidence against accuracy. If high-confidence answers are not meaningfully more accurate than low-confidence ones, the scores will not support automation, whatever the price.
for each labeled example:
send question + input to gemini-decision-1
record probability and confidence score
bucket results by confidence (0.5-0.6, 0.6-0.7, ... 0.9-1.0)
for each bucket:
accuracy = correct answers / total answers
compare accuracy across buckets to the stated confidence
set the auto-approve threshold where accuracy meets your risk limit
The pseudocode above is a testing pattern, not Google’s documented client code. Check the Gemini API reference in Google AI Studio for the actual request format before building on it.
Five Predictions for Decision Models #
These are analysis, not reporting. No company or person quoted above made these forecasts.
- Rivals will ship similar endpoints. If developers adopt a zero-output-billing decision API, competing labs will answer with their own, probably within the next year or so. The pricing pressure on output tokens for classification work is hard to resist.
- Calibration tests will arrive first from the community. Developers and independent researchers tend to publish reliability checks within weeks of a launch. Expect those results to shape reputation more than any vendor claim.
- Rubric scoring will replace some LLM-as-judge pipelines. Cheap first-pass grading at volume is a natural fit. Expensive judge models will remain for the hard cases.
- Agent frameworks will add decision gates. Frameworks that coordinate tools and sub-tasks can use quick yes/no checks between steps, cutting cost and delay in long runs.
- Output-token billing will matter less for routing and moderation workloads. As teams split work between decision endpoints and generative ones, the generative bill will shrink to the tasks that truly need prose.
The main risk to all five is the same: if independent testing shows weak calibration, the decision-model idea loses its edge, and teams fall back to prompted chat models or their own classifiers.
The Takeaway: A Narrow Model With a Wide Reach #
Gemini Decision 1 will not write a poem or draft an email. That is the point. By confining itself to closed-set decisions, it trades flexibility for price, speed, and a structured output that software can act on. At $0.10 per 1 million input tokens with no output billing, the cost case is clear on paper.
The proof case is still open. Google has confirmed the specs, but benchmark leadership, calibration quality, and per-task accuracy remain unconfirmed. Developers who test on their own labeled data in the next few weeks will learn more than any launch post can tell them.
Gemini Decision 1 FAQ #
What is Gemini Decision 1? It is a Google model, identified as gemini-decision-1, that handles closed-set decisions through the Gemini Decisions API. It returns probabilities and confidence scores instead of generating answer text token by token.
When did Google announce it? Google announced the Gemini Decisions API and Gemini Decision 1 on November 11, 2026.
How much does it cost? Google lists a price of $0.10 per 1 million input tokens, with zero output tokens billed. Free-tier limits are not confirmed in the announcement.
What kinds of questions can it answer? Yes/no, choice, and rubric-scoring questions. A request can include up to 1,000 independent questions.
What inputs does it accept? Text, images, audio, video, and PDFs, up to 256K tokens of input.
How fast is it? Google reports 150 to 250 milliseconds end to end. The announcement as cited does not publish the test conditions, so treat it as a vendor figure until independent tests appear.
Is it a “low-cost model” by Google’s own definition? No. That phrase is outlet shorthand. Google presents it as the model behind an API for fast, closed-set decisions, and the “low-cost” label is not an official product designation.
Where can developers try it? Through the Gemini API in Google AI Studio, according to Google’s announcement. Check the API reference there for request formats and current terms.