A laptop displays an AI evaluation dashboard with colored score bars and a green check mark

Gemini Decisions API Explained: Google’s New Model Scores Answers Instead of Writing Them

Key Takeaways

  • The Gemini Decisions API is Google's new endpoint, launched on 11 November 2026, for fast closed-set decisions: it scores fixed options and returns probabilities instead of generating text.
  • It runs on a new model, Gemini Decision 1, model ID gemini-decision-1, and is available through the Gemini API in Google AI Studio on the v1beta endpoint.
  • One request can evaluate up to 1,000 independent questions against a single shared multimodal input of up to 256K tokens, covering text, images, audio, video and PDFs.
  • Google reports median model compute of 50 to 100 milliseconds and end-to-end latency of 150 to 250 milliseconds, with pricing of 0.10 dollars per 1 million input tokens and zero output tokens billed.
  • The three question types are yes/no checks, multiple choice from 2 to 255 options, and ordered rubric scoring, and every answer carries a confidence score from 0 to 1.
  • Google says it already uses the API inside Gemini Notebook, Stitch, CC from Google Labs and Google Search, but the benchmark and latency figures are Google's own and have not yet been independently reproduced.

Google has spent the last two years teaching its Gemini models to write longer, reason harder and act more autonomously. On 11 November 2026, Google DeepMind went in the opposite direction and announced a model that writes nothing at all. The Gemini Decisions API is a new endpoint powered by Gemini Decision 1, a specialised model built for one narrow job: looking at a piece of evidence and answering a fixed set of questions about it, with numbers instead of sentences. Rather than generating an answer token by token, Gemini Decision 1 scores the candidate options in a single forward pass and returns probabilities and confidence scores. The launch came three weeks after OpenAI made its own Decisions API generally available on 22 October 2026, and it answers a pattern developers kept hitting: using large generative models as classifiers, routers and graders, and paying for full text generation when all they needed was a yes, a choice, or a score.

What the Gemini Decisions API is

Google's announcement, published on the Google blog on 11 November 2026 by Min Choi, a product manager at Google DeepMind, and Felix Yu, a principal scientist at Google DeepMind, describes the Gemini Decisions API as "a new endpoint for fast, closed-set decisions powered by our new Gemini Decision 1 model (gemini-decision-1), available through the Gemini API in Google AI Studio." The phrase "closed-set" does most of the work in that sentence. A closed-set decision is one where the possible answers are fixed in advance: yes or no, one of a list of options, or a point on a defined scale. The model cannot invent a fourth option, add a caveat, or answer a different question. It scores what it is given. Google positions the endpoint for what it calls "bounded choices like tool selection, policy checks, model routing, and context grading," and those four examples recur throughout the announcement because they describe the shape of the problem rather than a list of approved uses. Tool selection means choosing which tool an agent should call next. Policy checks mean testing content against a rule. Model routing means deciding which model, or how much reasoning effort, a request deserves. Context grading means scoring retrieved material for relevance before it reaches a generative model.

The model behind the endpoint is Gemini Decision 1, a distinct model rather than a mode of Gemini 3 or a prompt template wrapped around an existing model. Google describes it as built on Gemini's native multimodal architecture, so it can process text, images, audio, video and PDFs directly in a single forward pass. One request takes a single shared input of up to 256K tokens, together with up to 1,000 independent questions about that input. The input field uses the same Content block format as the Interactions API, according to Google's announcement, so developers already working with Gemini's newer API surfaces will recognise the shape of a request even though the endpoint itself is new.

Access is through the Gemini Developer API, on the v1beta endpoint, with a no-cost tier in Google AI Studio for prototyping. Google says support for Gemini in Google Cloud is coming soon, so at launch the endpoint is a Developer API product rather than a Cloud product. The google-genai software development kits cover the endpoint, and Google lists ecosystem integrations rolling out across OpenRouter, LangChain, Vercel, LiteLLM, Pydantic AI, Pipecat, LiveKit and OpenCode. Demo applications are available in Google AI Studio, including Doorstep Parcels, Speed Sketch and Find the Zoo Keeper, and Google's documentation covers Python, JavaScript and REST.

It is important to be clear about what the Gemini Decisions API is not. It is not a chatbot, not a replacement for Gemini 3, and not a general-purpose model with a new name. It cannot write an email, summarise a document, hold a conversation, or explain why it chose an option. If an application needs an explanation, it must get that from somewhere else, either by calling a generative model separately or by designing the questions so that the probabilities themselves carry the information. It is also not an open-weights model: it runs only on Google's hosted API, and there is no version to download and run locally. Readers who want the broader picture of where Gemini 3 fits into Google's lineup should start with our guide to Google Gemini 3: release date, features and news, which covers the flagship generative model that the Decisions API is designed to sit alongside, not replace.

The three question types

Every request to the Gemini Decisions API mixes up to three question types, and understanding them is understanding the product, because the type of a question decides the shape of the answer. Google documents all three in its announcement, and each one maps to a different kind of judgement that software makes all day long.

The first type is the yes/no check, which Google calls "noul" in its API. A yes/no question estimates the probability that a condition holds, with optional descriptions of what counts as true and what counts as false. Google's example is a photo of a breakroom counter checked against whether there is an uncleaned liquid spill on it. The answer is a probability, so calling code can set its own threshold: act automatically above 0.9, ask a human between 0.5 and 0.9, and treat anything below that as a no. A probability is a number the code can compare, log and tune, where a generative model's sentence would need parsing.

The second type is multiple choice, called "choice" in the API. A choice question selects a winner from 2 to 255 options and returns normalised probabilities for every candidate, not just the winner. Two options is a binary classification with named labels; 255 options is a large routing table or catalogue. In the breakroom example, the choice question asks which cleanup action fits the scene, with three criteria defined by the developer: wipe with a cloth, dispatch janitorial, or ready for meeting. The model returns the winning action and the probability of each, so the application can see whether the choice was a clear win or a near tie.

The third type is the ordered rubric, called "score" in the API. A rubric question grades an input across an ordered scale starting at 0, returning a continuous weighted score and per-level probabilities. In Google's example, the rubric rates the severity of the counter mess across three levels: clean and ready, minor localised spill, and major spill or safety hazard. Rubric scoring turns a judgement that is naturally a matter of degree, such as quality, severity, relevance or risk, into a number that can be sorted, averaged or thresholded. It is also the type where the design of the rubric matters most: a rubric with vague levels will produce vague scores, and the per-level probabilities show when the model is split between two adjacent levels.

How the Gemini Decisions API works: scoring, not generating

The technical idea behind the Gemini Decisions API is the difference between scoring and generating. A generative model produces its answer one token at a time, and each token depends on the ones before it, which is why a generative answer takes time to stream, costs more the longer it runs, and can vary between runs. Gemini Decision 1, according to Google, does not do that. It scores the candidate options in a single forward pass: the model reads the input and the questions once, computes a score for each option, and returns the results. There is no token-by-token decoding, no streaming, and no output text to parse. Latency is lower, cost is lower because there are no output tokens to bill, and the answer is structured, because the model can only return probabilities for the options it was given.

The shared input is the second half of the design. In a conventional setup, an application that needs twenty checks on a document would send the document twenty times and pay for its tokens twenty times. The Gemini Decisions API sends the document once, with all twenty questions attached, and bills the shared input once per request. Google states this explicitly: "Your shared input is billed once per request no matter how many questions you evaluate (each question adds only its own instruction and criteria tokens)." VentureBeat, working from Google's pricing page, illustrates the point with a 4,000-token record and twenty checks that add 50 tokens each: one 5,000-token request costs about 0.50 dollars per 1,000 records at Google's rate, while twenty separate calls that each resend the record would cost 8.10 dollars per 1,000 records before any retries. Those are VentureBeat's calculations from Google's published price, not an independent measurement, but they show why the shared-input design matters more than the headline per-token price.

The multimodal side of the input is where the Gemini Decisions API differs most from a text classifier. The shared input can combine text, images, audio, video and PDFs in one request, and Google's announcement gives two concrete pairings: a call recording with account metadata, and a scanned PDF claim with damage photos. A developer can tune the resolution of image and video inputs to control how much visual detail the model sees and how many tokens the media consumes, turning resolution down for a coarse check and up for fine-grained reading. The same endpoint can therefore serve a text-only policy check, an image-only quality check, and a combined audio-plus-metadata check with the same question format.

Speed, price and limits

Google's announcement leads with three numbers: 150 to 250 milliseconds of end-to-end latency, 0.10 dollars per 1 million input tokens, and zero output tokens billed. Those three numbers are the pitch, and each one needs a closer look, because each comes with conditions that Google states in the same announcement.

On speed, Google reports median model compute of 50 to 100 milliseconds and end-to-end latency of 150 to 250 milliseconds, across multimodal inputs and contexts up to 16K tokens, remaining nearly flat from 1 to 100 questions per request. That flatness is the direct result of scoring in a single forward pass. The 16K-token condition is important: Google's latency figure is stated for inputs up to 16K tokens, not for the full 256K-token context window, so a request near the maximum context will not necessarily run in 250 milliseconds. The median is also a median, not a guarantee, and Google has not published a percentile figure such as the time that 95 percent of requests complete within. Developers who need a latency guarantee for a user-facing feature should measure the endpoint on their own traffic before promising a number to their users.

On price, Gemini Decision 1 is priced at 0.10 dollars per 1 million input tokens and 0 dollars for output tokens, with an API no-cost tier in Google AI Studio for prototyping. There are no output-token charges, no variable thinking-token bills, and no separate audio transcription or OCR costs, according to Google, because the model reads media directly. Google also claims that, with zero output tokens billed, Gemini Decision 1 with the Decisions API is "nearly 5x cheaper across the shared benchmark suite than Gemini 3.5 Flash-Lite with the Interactions API." That is Google's own comparison on its own benchmark suite, and it should be read as a vendor claim rather than an independent finding. The free tier, as reported from Google's rate-limit pages, allows 200 requests and 50,000 input tokens per minute, which is generous for prototyping but will not carry a production workload.

On limits, the headline numbers are 1,000 questions per request, 2 to 255 choices per multiple-choice question, and a 262,144-token context window, which Google describes as 256K tokens and which covers the shared input plus the instructions and criteria for all questions. The 1,000-question ceiling is the largest of any decision endpoint currently available. It also raises a practical question Google's announcement does not answer: what happens to accuracy as the question count grows. Google's latency claim is flat from 1 to 100 questions, but the announcement states no latency or accuracy figure for 1,000 questions, and a thousand questions with detailed criteria will consume a large share of the context window. Reporting based on Google's documentation also notes that the API does not support context caching, the Batch API, or Flex and Priority inference. An application that repeatedly checks the same large document will pay for that document on every request, because there is no cache to reuse. Developers planning to use the full ceiling should test it on their own data, because a limit in the documentation is not a promise that performance holds at the limit.

Performance and calibration: what Google claims

Google's announcement includes a benchmarks section headed "Strong performance and calibration," and it is the part of the launch that most needs careful reading, because every figure in it is Google's own. The announcement states that, on benchmarks spanning agent routing, reasoning, ranking and multimodal understanding, Gemini Decision 1 "leads across the suite, with the lowest calibration error." Calibration error measures how well a model's confidence matches its accuracy: a model with low calibration error is one whose stated confidence can be trusted, so a 0.9 probability really does mean the model is right about nine times out of ten. For a decision endpoint, calibration is arguably more important than raw accuracy, because the whole workflow depends on trusting the probabilities enough to act on them automatically and to send only the uncertain cases to a human.

Secondary reporting of Google's benchmark charts gives the specific numbers behind the claim. NeuralDaily, reporting Google's comparison, states that Gemini Decision 1 scored 92.2 percent on JevBench, against 90.9 percent for GPT-6 Luna, the model behind OpenAI's Decisions API, and 90.0 percent for TypeSafe's Jev 1.14, and that its top-1 expected calibration error was 0.0250, against 0.0721 for GPT-6 Luna. VentureBeat reports the same calibration figure and notes that it is roughly half of Jev's 0.0494. The qualifiers matter: the tests were chosen by Google, and refusals and safety blocks count as incorrect in the comparison, according to reporting of the methodology.

What Google is already using it for

Google's announcement lists four internal uses, and they show where the endpoint fits. The first is dynamic model routing in Gemini Notebook, where the Decisions API directs incoming queries to the optimal model tier and thinking level; Google says it serves everyday queries with up to 40 percent lower latency while reserving deep reasoning models for complex tasks. The second is rapid design iteration in Stitch, where a rapid canvas experiment uses the Decisions API to generate playable wireframes in seconds and apply edits by voice or tap almost instantly. The third is emoji selection in CC from Google Labs, which picks the right emoji from a palette of more than 200 options in a fraction of a second. The fourth is a safety layer for MCP tools in Google Search, which detects adversarial behaviour and content against adversarial evaluations within the latency envelope. The pattern is consistent: the decision is small, it is needed constantly, and the cost of being wrong is bounded because a fallback exists.

Gemini Decisions API versus OpenAI Decisions API

The obvious comparison is with OpenAI's Decisions API, which became generally available on 22 October 2026, three weeks before Google's launch. The two endpoints share the same idea, the same three question shapes, and the same headline price: OpenAI's endpoint also charges 0.10 dollars per million uncached input tokens with no output-token charge, runs on a single model, GPT-6 Luna, and is reached through a dedicated endpoint. The differences are in the details. Google allows up to 1,000 questions per request, while OpenAI's generally available endpoint allows up to 400, raised from 200 in beta. Google accepts audio, video and PDF inputs natively, while OpenAI's endpoint accepts text, images, JSON and conversation evidence but does not support files, audio or item references in Decisions input, according to reporting of OpenAI's documentation. OpenAI, in return, offers prompt caching on the shared input, JSON input, and support for Zero Data Retention and HIPAA use for eligible customers, none of which Google's launch documents promise. Google's latency claim is 150 to 250 milliseconds end to end; OpenAI claims its Decisions calls run about ten times faster than the same model through the Responses API, a vendor claim that reporting has noted is published without a public workload or latency distribution. Neither company's speed claim has been independently reproduced, so a team choosing between them should test both on its own traffic rather than deciding on the announcements.

The price match is unlikely to be a coincidence. Both companies have priced input at the same 0.10 dollars per million tokens, which suggests the decision-endpoint market is already converging on a standard price, and that competition will happen on limits, modalities and ecosystem rather than on the per-token rate. For developers, that is good news: the choice can be made on which endpoint fits the workload, with the knowledge that switching later will not mean rethinking the cost model. For Google, the launch is a defensive move. OpenAI had a three-week head start and a generally available product; Google's answer is a higher question ceiling, broader multimodal input, and a lower reported calibration error. Whether that is enough to win developers who have already built on OpenAI's endpoint will depend on independent benchmarks and on whether the ecosystem integrations Google lists arrive quickly.

Who should use it, and who should not

The Gemini Decisions API fits applications that make many small, bounded judgements about evidence they already have: content moderation queues, support ticket routing, document processing, retrieval pipelines where each passage needs a relevance grade, and agent systems where each step needs a tool choice. In all of these, the input is available, the options are known, and the value of the answer is in the number, not in an explanation. The free tier in Google AI Studio makes any of these cheap to prototype, and shared-input billing makes them cheap to run at volume.

It does not fit applications that need open-ended answers, explanations, or conversation. It cannot summarise, draft, or reason out loud, and it cannot choose among options that cannot be listed in advance. It does not fit high-stakes decisions made without a human in the loop, because a probability, however well calibrated, is not a judgement about whether the decision should be automated at all. It also does not fit teams that need Google Cloud support, context caching, or batch processing today, because those are not available at launch. Our broader look at where agentic and multimodal systems are heading, in Exciting insights on latest trends in AI technology 2026, puts this launch in context: the industry is moving from models that do everything to systems that combine specialised models, and the Decisions API is one of the clearest examples of that shift.

The bottom line

The Gemini Decisions API is a small, precise product, and that is its strength. Google has not launched another chatbot or flagship model. It has launched a way to ask a model a thousand small questions at once and get numbers back in a fraction of a second, for a tenth of a dollar per million input tokens. The design is coherent: a single forward pass, a shared input billed once, three question types, and confidence scores that let code decide when to ask a human. The open questions are also clear. The benchmarks are Google's own, the independent ranking is less flattering, the latency figure covers inputs up to 16K tokens rather than the full context window, and the launch lacks caching, batch processing and Google Cloud support. Developers with a routing, grading or moderation workload should try the free tier, measure calibration on their own labelled data, and compare the result with OpenAI's endpoint before committing. The Gemini Decisions API does not replace generative AI. It gives generative AI a faster, cheaper way to decide what to do next, and that may turn out to be the more important launch.

Sources

Similar Posts