Google just opened a new door for developers who need instant, probabilistic judgments across many data types. The Gemini Decisions API, built on the Gemini Decision 1 model, lets you submit up to 1,000 yes/no, multiple‑choice, or rubric‑scoring questions in a single pass and get calibrated confidence scores for text, images, audio, video and PDFs. By handling all those evaluations in one go, the service promises lower latency and cost, making it a practical fit for routing user queries, grading content, or enforcing policy rules in real time.
In this post we’ll walk through how to get started with the API—fetching an API key from Google AI Studio, wiring up the Python, JavaScript or REST examples, and interpreting the confidence outputs. We’ll also explore typical use cases, discuss the limits of a closed‑set decision model, and compare the Gemini approach to other retrieval‑augmented or quantized LLM pipelines that aim to squeeze inference cost without sacrificing accuracy.
What happened
Google opened the Gemini Decisions API to the public on Nov 11, 2026. The announcement came as a blog post on the Google AI site, where the company highlighted the new endpoint as part of the broader Gemini API family. It is positioned as a “fast, calibrated multimodal decisions” service, aimed at developers who need to make large numbers of closed‑set predictions in a single call.
The service runs on the Gemini Decision 1 model, identified in the documentation as gemini‑decision‑1. This model is the first dedicated decision‑making engine in the Gemini lineup, separate from the generative Gemini 1 series. According to the post, the model can ingest text, images, audio, video, and PDFs, producing probabilistic confidence scores for each query it receives.
What makes the API practical for production workloads is the batch capacity. A single request can contain up to 1,000 yes/no, multiple‑choice, or rubric‑scoring questions, and the system returns a calibrated confidence score for each item in one pass. The blog notes that this “single‑pass” approach reduces latency and cost compared with issuing separate calls for each question, which is useful for tasks such as routing user requests, grading content, or enforcing policy rules.
Developers can start using the endpoint immediately by obtaining an API key in Google AI Studio and following the provided Python, JavaScript, or REST guides. The announcement emphasizes that the Decisions API is a cost‑effective way to add probabilistic decision logic to applications without building a custom model pipeline from scratch.
Why it matters
Fast, calibrated decisions let us treat a whole class of routing problems as a single API call instead of stitching together custom pipelines. With the Gemini Decisions API you can evaluate up to 1,000 yes/no, choice, or rubric‑scoring questions in one pass, which means a request that would normally require a series of model calls, post‑processing, and rule checks can now be answered in milliseconds. That speed makes it practical to use the service for real‑time query routing, content grading, or policy enforcement without the latency overhead of a bespoke solution.
The API also returns a confidence score for each question, turning a binary or categorical output into a probabilistic signal. Those scores let us set thresholds, combine multiple decisions, or feed the result directly into downstream logic that expects a likelihood rather than a hard label. Because the confidence is computed alongside the decision, we avoid a separate calibration step and can trust the numbers for downstream risk management or fallback handling.
What really widens the appeal is the multimodal support: the same endpoint can ingest text, images, audio, video, and PDFs. This means you can grade a user‑submitted essay, verify that an uploaded image complies with brand guidelines, check whether a short audio clip contains prohibited language, or enforce policy on a PDF contract—all with the same call pattern. By handling diverse data types out of the box, the Decisions API removes the need to build and maintain separate classifiers for each modality, letting developers focus on the business rules that matter.
In practice, the combination of sub‑second latency, built‑in confidence, and multimodal reach translates into a cost‑effective way to embed intelligent decision making wherever a fast, reliable verdict is required. Whether you’re triaging support tickets, moderating user‑generated content, or gating feature access based on policy checks, the Gemini Decisions API gives you a ready‑made, production‑grade building block that scales without the engineering overhead of a custom pipeline.
How it works (background)
The Gemini Decisions API is built around a closed‑set decision model called Gemini Decision 1. Rather than issuing a separate request for each query, the service lets you submit a batch of up to 1,000 yes/no, multiple‑choice, or rubric‑scoring items and processes them in a single forward pass of the model. Because the same inference run handles the whole batch, you get a fast, cost‑effective way to evaluate many questions across text, images, audio, video, or PDFs without the overhead of repeated network round‑trips.
For each possible answer the model emits a calibrated probability, effectively a confidence score. Those scores give you a quantitative measure of how likely the model thinks each option is correct, which you can compare against a threshold that matches your application’s risk tolerance. For example, a high‑confidence “yes” might trigger an automated action, while a lower confidence could route the request to a human reviewer or a fallback system.
The API is exposed through the Gemini API in Google AI Studio. After you generate an API key in the Studio console, you can call the endpoint using any of the officially supported client libraries. Google provides ready‑to‑use wrappers for Python and JavaScript, and there’s also a generic REST interface for any language that can make HTTP requests. The documentation walks you through constructing the request payload, handling the batch response, and interpreting the returned probability vectors.
Because the service runs the entire batch in one model pass, latency scales with the size of the batch rather than the number of individual questions. This design makes the Gemini Decisions API well suited for real‑time decision pipelines—such as content moderation, policy enforcement, or automated grading—where you need many calibrated answers quickly and reliably.
- 1
Get API key
Generate an API key in Google AI Studio.
- 2
Create batch request
Build a payload with up to 1,000 items, specifying modality for each.
- 3
Call endpoint
Send the request to the Gemini Decisions API via Python, JavaScript, or REST.
- 4
Receive scores
Get a JSON response with calibrated confidence scores for every item.
- 5
Apply decisions
Use the scores to route, grade, or enforce policies in real time.
The key details and numbers
The Gemini Decisions API lets you push up to 1,000 yes/no, choice, or rubric‑scoring questions in a single request. By accepting a batch of that size, the service can evaluate each item in one forward pass of the Gemini Decision 1 model, which means the latency you see is the cost of a single inference rather than the sum of 1,000 separate calls. In practice this translates to a noticeable speed advantage when you need to route many queries, grade large collections of content, or enforce policy checks at scale.
All of the usual multimodal inputs are supported. You can send plain text, images, audio clips, video snippets, or PDF documents together in the same batch, and the model will produce a calibrated confidence score for each question regardless of the underlying modality. This flexibility removes the need to pre‑process or convert assets into a single format before calling the API, simplifying pipelines that already work with mixed media.
To start using the endpoint, you first obtain an API key from Google AI Studio. The key grants access to the Gemini‑decision‑1 model through the Gemini API, and the documentation provides ready‑to‑run examples in Python, JavaScript, and plain REST. Once you have the key, you can construct a request that includes the batch of up to 1,000 items, specify the modality for each, and receive a JSON response containing the decision probabilities and confidence levels for every question in that single pass.
What it means for developers
The Gemini Decisions API lets us replace a cascade of individual model calls with a single request that evaluates up to 1,000 yes/no, choice, or rubric‑scoring questions in one pass. Because the endpoint returns confidence scores for every question together, the network round‑trip happens only once, which cuts latency and reduces the amount of data transferred between our service and Google’s servers. In practice that means a content‑moderation pipeline can score a batch of user posts, an automated‑grading system can assess an entire assignment, or a routing layer can decide where to send each request without spawning a separate LLM call for every item.
Batch processing also simplifies the code we write. Instead of looping over a list of inputs and handling retries or rate‑limit errors for each iteration, we construct a single payload and let the API do the heavy lifting. The reduced number of HTTP calls translates directly into lower compute spend on the client side and fewer chances for transient failures. For teams that already pay for cloud compute, the per‑decision cost drops because the Gemini Decision 1 model is optimized for high‑throughput, closed‑set inference.
A distinctive advantage of the new endpoint is its multimodal reach. The same request can ingest text, images, audio, video, or PDFs, so we can combine visual cues (e.g., a screenshot of a UI) with spoken instructions or written content when making a decision. This opens up richer use cases such as verifying that an uploaded image complies with policy while simultaneously checking the accompanying caption, or routing a support call based on both the caller’s voice tone and the transcript of their request. By pulling together signals from different modalities, developers can build decision‑making components that feel more context‑aware without stitching together separate models.
Overall, the API’s design encourages us to think in terms of “decision batches” rather than isolated predictions. That shift reduces both operational overhead and monetary cost, while the multimodal support lets us craft more nuanced, real‑time experiences that were previously too expensive or complex to implement.
Limits and caveats
The Gemini Decisions API is purpose‑built for closed‑set tasks – it only returns yes/no answers, multiple‑choice selections, or rubric scores. Anything that requires free‑form text, paragraph‑level summarisation, or creative generation is outside the contract of the endpoint, so you’ll need to fall back to a standard Gemini generation model for those use‑cases. This design keeps the latency low and the cost predictable, but it also means the API can’t be used as a drop‑in replacement for open‑ended LLM calls.
Every response includes a confidence score that reflects the model’s internal probability estimate for the chosen option. These numbers are useful for routing or triage, yet they are not calibrated guarantees. In high‑stakes scenarios – for example, automated policy enforcement or medical triage – you’ll likely want to apply post‑hoc calibration (such as temperature scaling or isotonic regression) and set thresholds that reflect your risk tolerance. Treat the scores as a guide rather than an absolute measure of correctness.
Because the service launched only recently, Google has not locked in long‑term quota limits or pricing tiers. The public documentation notes that usage quotas and cost structures are “subject to change,” and developers are encouraged to monitor the Google AI Studio dashboard for updates. Sudden adjustments to request limits or per‑call pricing could affect budgeting and scaling plans, so it’s prudent to build in alerts or fallback paths that can gracefully handle a quota‑exhaustion error.
Finally, keep an eye on the release notes. Early‑stage APIs often receive iterative improvements that can alter response formats, add new closed‑set options, or refine the confidence calibration. Staying current with the official blog and the API changelog will help you avoid surprises and make the most of the Gemini Decisions service as it matures.
Key takeaways
- The Gemini Decisions API, launched on Nov 11 2026, is powered by the new Gemini Decision 1 model and lets you evaluate up to 1,000 yes/no, multiple‑choice, or rubric‑scoring questions in a single pass.
- It works across multimodal inputs—including text, images, audio, video, and PDFs—returning calibrated confidence scores for each query.
- By computing many decisions in one request, the API offers a cost‑effective way to route queries, grade content, or enforce policy rules at scale.
- Developers can start using the service immediately by obtaining an API key in Google AI Studio and following the provided Python, JavaScript, and REST documentation.
Visual summary
The key points as images. Tap one to open it, or save it to share.


