Gemini Decisions API 🚀: Fast Multimodal AI Routing14 min read2,757 words

Gemini Decisions API 🚀: Fast Multimodal AI Routing

Discover how the Gemini Decisions API (Gemini Decision 1) routes multimodal AI—classification, policy checks, costs, latency & risk. Learn more now!

Gemini Decisions APIGemini Decision 1multimodal AIAI model routingAI decision API
Gemini Decisions API 🚀: Fast Multimodal AI Routing

Gemini Decisions API: A Control Layer for AI That Needs to Choose

A lot of AI features don't need another paragraph of generated text. They need a bounded decision: send this request to the right model, flag whether an image shows a safety issue, or pick the next action from a fixed set. Using a generative model for that can add latency, cost, and yet another parsing step.

Google's Gemini Decisions API is built for that narrower job. Powered by Gemini Decision 1, it takes shared input (text, image, audio, video, or PDF), answers one or more questions, and returns options with probabilities and confidence scores. Google reports 150-250 ms end-to-end latency and no output-token charges. Those numbers are worth paying attention to - but they don't automatically make this a fit for every classification or routing problem.

This guide walks through how the API works, where its decision "primitives" can simplify a product, and what you should test before dropping it into a production control path. The real question isn't whether a model can pick an answer. It's whether a bounded, probabilistic decision is dependable enough for what your system will do next.

What is the Gemini Decisions API?

The Gemini Decisions API is an endpoint for closed-set decisions: instead of composing an open-ended response, your system chooses among defined outcomes. Google introduced it with Gemini Decision 1, available through the Gemini API in Google AI Studio. In the source announcement, Google describes the API as primitives for tasks like tool selection, policy checks, model routing, and context grading.

That distinction matters. With a typical generative call, an application asks for text and then has to interpret or validate it before acting. A decision endpoint scores the options you provide. For a model router, those options might be "fast model," "reasoning model," or "refuse." For a support workflow, they might be "eligible," "needs review," or "ineligible."

The API supports up to 1,000 independent questions over a shared input of up to 256K tokens. Google says the shared input is billed once per request, and each question adds its own instruction and criteria tokens. The model scores candidates in a forward pass rather than generating an answer token by token. Google reports 50-100 ms of model compute and 150-250 ms end-to-end latency. Your real-world latency will still depend on network conditions, request size, and what else runs around it.

The three decision types

The API supports three question types, each meant for a different kind of choice:

  • Yes/no (noul) estimates the probability that a condition holds. Optional true/false descriptions can help define what counts as either outcome.
  • Choice selects the best option from 2 to 255 candidates and returns the winner along with normalized probabilities for every candidate.
  • Score assigns a graded result against an ordered rubric starting at zero, returning a weighted score and probabilities for each rubric level.

They're not interchangeable. Yes/no is a good fit when the business rule is genuinely binary. Choice is what you want when the system must select an action or route. Score can work for ordered assessments, but don't treat it like a precise measurement unless you test how the rubric behaves on your data.

Why this is different from ordinary generation

You can prompt a generative model to output a label from a fixed list. The key difference here is the interface and execution pattern: the Decisions API is centered on evaluating candidate options, not generating text and then parsing it. That can reduce decoding overhead and cut down on brittle output-handling code.

But it doesn't remove the hard part - defining the decision clearly. If two options overlap, the model can still pick a winner, even though the application hasn't actually made the policy clearer. Closed-set output is most useful when your product already has a meaningful set of actions, categories, or thresholds - rather than trying to force an ambiguous process into something that looks deterministic.

How does it make multimodal decisions?

Gemini Decision 1 uses Gemini's multimodal setup to evaluate text, images, audio, video, and PDFs from a single shared input. You can mix modalities in one request - for example, a call recording plus account metadata, or a scanned claim plus photos of the damage. The API can then answer multiple questions about the same material.

This approach can reduce the glue code you'd otherwise write between separate "perception" and "classification" steps. A claims workflow might need to pull info from a form, inspect images, and judge severity. A conventional pipeline could run OCR, an image model, and a classifier, then reconcile results. A shared multimodal decision request can give you a first pass without juggling as many separate calls. That said, it doesn't automatically mean the result is accurate enough for something like an insurance decision.

Google also says image and video resolution can be tuned to control visual detail and token cost. That's a real trade-off: higher detail can help with small or subtle features, while lower detail can reduce input costs. The right setting depends on the question. Spotting a large spill is different from reading a serial number or identifying a hairline crack.

One input, several questions

The API's unit isn't "one prediction." It's "one shared input plus a set of questions." Take a workplace inspection example with a short note. One request could ask whether there's a spill, what cleanup action fits best, and how severe the issue is. Each question can use a different decision type while still grounding everything in the same evidence.

That structure has practical value. You avoid resending the same large input for every classification, and you keep related decisions tied together. It also tends to map cleanly onto workflows: a likely spill could trigger cleanup, while a high-severity result might route to a human reviewer.

The confidence score (0 to 1) gives you a signal for handling uncertain cases. Just don't mistake it for a universal guarantee. A score of 0.9 doesn't automatically mean "90% correct" in your environment. That interpretation depends on calibration against data that looks like your real traffic. Use confidence as an input to a routing policy you test - not as a magical truth label.

Latency and cost claims in context

Google reports median model compute of 50-100 ms and end-to-end latency of 150-250 ms. It also says latency stays nearly flat from 1 to 100 questions per request in tests involving multimodal inputs and contexts up to 16K tokens. The broader API limit is 256K tokens, so you shouldn't assume the same latency behavior at the maximum.

Pricing, per Google, is $0.10 per 1 million input tokens and $0 for output tokens. Google also mentions that its shared benchmark suite was nearly five times cheaper than Gemini 3.5 Flash-Lite with the Interactions API. That's a vendor-reported comparison on that suite, not a guarantee you'll always see fivefold savings. Your cost depends on input size, request volume, and how much question text and criteria you include.

Where can teams use it?

The best use cases are control points where your system must choose among known options quickly. Model routing is an obvious example. You can classify an incoming request as routine, complex, or requiring a specific capability and then direct it to an appropriate model tier. A lightweight decision call can help reserve slower or more expensive reasoning for tasks that truly need it.

Google says Gemini Notebook uses the API to route queries to a model tier and thinking level, reporting up to 40% lower latency for everyday queries while holding deeper reasoning in reserve for harder ones. That's a product-specific result, not a general promise. If you try similar routing, measure both sides: the time saved on ordinary requests and the cost of misrouting cases that need deeper reasoning.

Other plausible applications include selecting a tool, triaging support tickets, checking a document against a policy, or assigning an image to one of several review queues. For each case, decide what runs automatically and what gets escalated when evidence is unclear. If the decision matters, a human review path belongs in the design - not in a "maybe we'll do that later" plan.

Separate decision logic from generation

A practical architecture is to keep the decision model's job narrow and let a separate component handle explanations or content generation. For example, the Decisions API can choose whether a query needs a fast answer model or a deeper reasoning model. The selected model then produces the user-facing response.

This split can make your system easier to debug. You can test routing quality without mixing it with answer quality, and you can change the candidate options without rewriting a prompt that also generates user-facing text. It can also make failures more legible: a wrong route is a routing problem, not an answer quality problem.

The trade-off is real, too. Another model call adds another dependency - along with additional latency, failure modes, and operational cost. A separate control layer is worth it when the routing/triage benefit outweighs that overhead. If the app is small and the workflow is simple, it might just be extra complexity.

Fit the decision to the risk

Google's announcement also describes use inside its own products: Stitch uses decisions in a rapid design experiment, CC selects an emoji from a large palette, and Google Search uses the API as a safety layer for adversarial behavior and content. Those examples cover very different stakes. Picking an emoji is not the same kind of failure as blocking a user or affecting eligibility for something sensitive.

Use that difference to set your automation boundary. A low-impact choice can often tolerate an occasional mistake and recover through user feedback. A decision that touches access, money, safety, or eligibility needs tighter thresholds, stronger evaluation, and a clear escalation path. The API provides scores; your product and policy determine what scores are allowed to trigger actions.

What should you check before production?

Start with the decision contract, not the API call. Write down the candidate outcomes, define each one in observable terms, and state what the application does after each outcome. If your categories overlap - or if common situations aren't represented - fix the taxonomy before you test the model. A model can't turn a vague policy into something operational just because it returns probabilities.

Next, assemble evaluation data that actually resembles real use. Include normal inputs, edge cases, poor-quality images or audio, and examples where the correct answer isn't obvious. For multimodal workflows, vary the evidence conditions that affect interpretation: image resolution, lighting, scanned documents, accents, background noise, and missing context. Keep a held-out set so you aren't only judging changes against the same examples you used to tune prompts and criteria.

Evaluate errors, not just overall accuracy

Overall accuracy can hide the failures that matter. For routing, measure how often a complex query goes to an underpowered model - not just how many routes are correct overall. For safety checks, look at false negatives and false positives separately. The costs are often asymmetric: blocking something harmless frustrates users, while missing something harmful can create a much bigger operational and legal problem.

Check calibration too. If the system reports high confidence on incorrect decisions, a confidence-based fallback won't save you. Break predictions into confidence ranges and compare reported confidence to observed correctness on your test set. Repeat the analysis after you change input distributions, candidate criteria, or model versions.

Finally, write down an explicit uncertainty policy. For example: high-confidence routine cases can run automatically; borderline cases might be retried or routed to a stronger model; low-confidence or high-impact cases should go to a human. Your thresholds should come from measured error costs and available review capacity - not from picking a round number that feels intuitive.

Test the full system envelope

Benchmark end-to-end behavior under realistic conditions. Include network time, peak request volume, large inputs, retries, and downstream processing. Google's median latency may look great, but production experience is shaped by tail latency and availability as much as the median. A decision that usually arrives fast can still be a bad fit if occasional slow requests delay a user-facing workflow.

Track input-token usage and how you design questions. Since input is billed and output isn't, sending a large shared input can dominate cost even when the decision response doesn't generate long text. Reusing one shared input across multiple questions can help, but extra criteria and instructions still add tokens. Measure cost per completed workflow, not just cost per million tokens.

Also plan for failure. Decide what happens when the service times out, returns something unexpected, or becomes unavailable. A fallback might use a simpler deterministic rule, another model, a queue, or a human reviewer. Keep enough logging to investigate decisions, and apply appropriate privacy controls for sensitive audio, images, and documents.

Treat benchmarks as a starting point

Google reports that Gemini Decision 1 leads its benchmark suite across agent routing, reasoning, ranking, and multimodal understanding, with the lowest calibration error. The company also reports lower cost than its comparison model on the shared suite. Those claims are useful for a shortlist, but they don't replace an evaluation on your own data and definitions.

Benchmarks answer a constrained question: how did systems perform on a chosen set of tasks under specified conditions? Your deployment adds different users, inputs, policies, and failure costs. Run a side-by-side test against the system you already use, and include the cost of human review, downstream errors, and engineering maintenance. A lower API bill isn't a win if the workflow ends up creating more exceptions.

Conclusion

The Gemini Decisions API targets a real gap in AI app design: many systems need a fast, structured choice, not another generated response. Its multimodal input, three decision types, shared-question approach, and zero output-token pricing can simplify routing and triage workflows when your options are clear.

But whether it's worth it still depends on your data and the consequences of being wrong. Define the decision contract, test calibration and failure modes, and compare end-to-end workflow cost and latency with your current approach. If the API helps you make bounded decisions more reliable and easier to operate, it can be a useful control layer. If the categories are fuzzy or the action is too high-stakes for unvalidated automation, keep a human or deterministic rule in the loop.

Frequently Asked Questions

It is designed for bounded choices such as tool selection, model routing, policy checks and context grading. Instead of generating free-form text, Gemini Decision 1 scores candidate outcomes and returns probabilities or confidence information. The application can then decide whether to act, retry or escalate.
The API can process text, images, audio, video and PDFs, including combinations of modalities in one shared input. Google lists an input limit of up to 256K tokens. Image and video resolution can be adjusted to balance visual detail against token use and cost.
Google announced pricing of $0.10 per 1 million input tokens and no charge for output tokens. The shared input is billed once per request, while question instructions and criteria add their own input tokens. Actual cost depends on input size and request design.
No. A confidence score is useful only when its relationship to correctness has been evaluated on data representative of your application. Measure calibration, examine errors by confidence range and route uncertain or high-impact cases to an appropriate fallback or human reviewer.

Related articles