Gemini Decisions API — Google’s Fast Decision API for AI Agents, Powered by Gemini Decision 1

Late on a Tuesday afternoon, the support system receives a new ticket: a screenshot of an error and a few lines of description. Before the agent can do anything useful, it has to answer a stream of small questions — classify it, judge severity, pick a tool. Each question is one call to a large LLM, and you never know which answers are guesses.

Multiply that by thousands of tickets a day, and you have a system that is slow, expensive, and silently wrong. Gemini Decisions API, launched on 11/11/2026, separates “deciding” from “generating text” — fast, cheap, and returning measurable confidence.

What Is Gemini Decisions API?

How a decision model differs from a text-generating LLM

A text-generating LLM answers in free-form prose: you ask an open question, it writes a paragraph, and your code has to parse that paragraph to extract a decision — slow, expensive, and fragile.

A decision model does the opposite: it does not generate text, it scores a predefined set of options and returns probabilities with a 0–1 confidence. Most decisions inside an agent are closed-set — they never needed a full text-generating model.

Gemini Decision 1 — the model behind the API

Gemini Decision 1 (gemini-decision-1) from Google DeepMind launched with the API on 11/11/2026, accessed through the Gemini API in AI Studio, on the v1beta endpoint. One request holds up to 1,000 independent questions over a shared multimodal input of up to 256K tokens.

Published pricing: $0.10 per 1M input tokens, $0 output tokens. The shared input is charged only once per request. AI Studio has a no-cost tier for prototyping.

Three question types: noul, choice, score

• noul (yes/no): estimates the probability that a condition is true or false. Use it for policy checks and error detection.
• choice (2–255 options): returns the winning option plus normalized probabilities for every candidate. Use it for model routing and tool selection.
• score (ordered rubric starting from 0): returns a weighted continuous score plus the probability of each level. Use it for quality scoring and evaluating agent output.

Confidence turns this API into “a control layer”: your code sets thresholds — 0.8 or above runs automatically, below that it escalates to a larger LLM or a human reviewer.

This API is for developers building AI agents, DevOps/SRE teams running agents in production, and IT managers controlling AI costs. It is not for anyone who needs free-form text or multi-step reasoning.

Architecture and How It Works

flowchart TD
    A["Shared multimodal input<br/>text / image / audio / video / PDF<br/>256K tokens — charged once"] --> B["client.decisions.create<br/>model gemini-decision-1<br/>up to 1,000 questions<br/>noul / choice / score"]
    B --> C["Gemini Decision 1<br/>a single forward pass<br/>no free-form token generation"]
    C --> D["Structured output<br/>answer + probabilities<br/>+ confidence 0–1 / question"]
    D --> E{"Routing layer in code<br/>confidence threshold ≥ 0.8"}
    E -->|High confidence| F["Automatic branch<br/>route to model / tool / action"]
    E -->|Low confidence| G["Fallback branch<br/>larger LLM / human review"]
    F --> H["Log decision + confidence<br/>tune thresholds"]
    G --> H

Published latency (per Google): 150–250 ms end-to-end, 50–100 ms median model compute with inputs up to 16K tokens, nearly flat from 1 to 100 questions per request.

Why it is fast and cheap

The shared input is encoded once, and every question shares it. Each question only adds the tokens of its own instructions and criteria.

In my view, the most important part is the pricing model: routing cost used to grow with the number of decisions, but with Decisions API it grows with the input — so ask every decision you might need up front, in one request. That only holds when three conditions are met: the questions share the same input, confidence is calibrated on your own data, and batches are split by independent failure unit. The real value sits in the threshold and fallback layer on the client side.

Confidence score — the most important component

Confidence 0–1 is the calibrated probability of the answer. Google says Decision 1 leads its own benchmark with the lowest calibration error, compared with Jev, OpenAI GPT-6 Luna, and Gemini 3.5 Flash-Lite — but this is a benchmark published by Google itself, with no independent accuracy figures, so read it only as a directional reference.

Technical limits

Workflow: AI Studio (get an API key, no-cost tier) → Gemini API v1beta endpoint → google-genai SDK / REST / JS → the routing layer in your code. Google Cloud is “coming soon” — not available yet.

Limits: at most 1,000 questions per request, input up to 256K tokens, choice up to 255 options, closed-set decisions only, and the v1beta endpoint means the schema may change.

How to Use Gemini Decisions API

You need a Google AI Studio account and API key, Python 3.x with the google-genai SDK 3.2 or newer (per the official docs), and a basic understanding of LLM API calls and JSON handling. This section was not tested against the live API — the guide follows the official documentation.

Step 1: create an API key in Google AI Studio (no-cost tier). Step 2: install the SDK (pip install -U google-genai). Step 3: put the API key in an environment variable — never hardcode it or commit it to a repo:

export GEMINI_API_KEY="..."

Official Python sample code

Google’s announcement example: a photo of a kitchen counter plus a text note, evaluated with all three question types in a single request:

from google import genai

client = genai.Client(http_options={"api_version": "v1beta"})

result = client.decisions.create(
    model="gemini-decision-1",
    input=[
        {
            "type": "image",
            "uri": "https://storage.googleapis.com/generativeai-downloads/images/spill.jpg",
            "mime_type": "image/jpeg",
        },
        {
            "type": "text",
            "text": "Breakroom counter check before the 9 AM client meeting.",
        },
    ],
    questions={
        "has_spill": {
            "type": "noul",
            "instructions": "Is there an uncleaned liquid spill on the counter?",
        },
        "next_action": {
            "type": "choice",
            "instructions": "Which cleanup action fits the scene?",
            "criteria": {
                "wipe_with_cloth": "Small counter spill with a cloth or towel already nearby.",
                "dispatch_janitorial": "Large floor hazard, broken glass, or active leak.",
                "ready_for_meeting": "Counter is clean and ready.",
            },
        },
        "severity": {
            "type": "score",
            "instructions": "Rate the severity of the counter mess.",
            "criteria": [
                "Clean and ready.",
                "Minor localized spill.",
                "Major spill or safety hazard.",
            ],
        },
    },
)

What each parameter means: model selects gemini-decision-1; input is the shared multimodal content; questions defines each question with its instructions and criteria.

An exercise to try yourself: keep the same pattern, only change the questions — swap the kitchen counter photo for a support ticket, and turn the three questions into: policy violation or not (noul), which team to route to (choice), and how many priority points (score).

Verifying results and common errors

After the call, check: does the response contain an answer, probabilities, and confidence for every question; is the confidence distribution sensible.

Common errors: wrong api_version (it must be v1beta); more than 1,000 questions or 256K tokens; a choice outside the 2–255 range; a score rubric not starting from 0; an API key that is exposed or expired.

Technical Assessment

Strengths. Fast: 150–250 ms end-to-end per Google, nearly flat as the question count grows. Cheap: $0.10 per 1M input tokens, $0 output, shared input charged once; Google says it is nearly 5x cheaper than Gemini 3.5 Flash-Lite via the Interactions API on its own benchmark — a vendor claim, not independently verified. Structured output with confidence lets code route automatically and fall back on clear thresholds.

Weaknesses and limits. Closed-set decisions only: no free-form text, no long explanations, no deep reasoning. The v1beta endpoint and Google Cloud “coming soon” mean it is not yet stable for strict production use. The benchmark is Google’s own, not independently verified, with no published accuracy figures.

Security and operations. Use the API key only through an environment variable or secret manager, never commit it to a repo; prototype keys should have limited quotas. Data sent to the API — including internal images, video, and PDFs — leaves your infrastructure, so review sensitive data and PII before sending. Do not use Decisions API as your only security layer: it only filters and classifies, it does not replace access control or human review.

Performance and scalability. Figures with a source, per Google: 150–250 ms end-to-end latency, 50–100 ms median model compute with inputs up to 16K tokens, nearly flat from 1 to 100 questions; Gemini Notebook cut latency by up to 40% using Decisions API as a router. There are no independent figures, and no throughput or RPS claims.

Comparison with OpenAI Decisions API and Jev

This table compares only criteria with verifiable sources; cells without figures are left blank. Choose Gemini if you already use the Google ecosystem and need low cost for repeated decisions; choose OpenAI or Jev if you need the cascade pattern — see the Jev analysis. Once a decision is made, the agent still needs infrastructure to run on: the Claude Code on Bedrock AgentCore article describes one way to deploy an agent in production on AWS.

Real-World Use Cases

For AI agents: model routing — pick the right model tier for each request, as Gemini Notebook does internally. Running many agents at once also needs routing to hand work to the right place — see Orca — running many AI coding agents in parallel. Tool selection: pick 1 of N tools before calling. Policy checks before tool calls: Google Search uses Decisions API as a safety layer detecting adversarial behavior with MCP tools.

For businesses and IT admins: support ticket routing — classify, prioritize, and pick the handling team in a single request. AI cost management: replace large LLM calls for small decisions with a decision model, using confidence to call the expensive LLM only when truly needed. To independently verify agent behavior, see iFixAi — independent auditing of AI agents.

For DevOps / SRE: alert and log triage — on the same log payload, ask noul (is this a real incident?), choice (which priority?), score (how severe, on how many points?).

Google also introduced three demo apps — Doorstep Parcels, Speed Sketch, Find the Zoo Keeper.

When NOT to Use Gemini Decisions API

Open-ended decisions, long explanations, or multi-step reasoning — that is still the job of a text-generating LLM. High-risk decisions (medical, legal, financial) that need independently verified accuracy — none exists yet. Environments requiring on-prem or Google Cloud — Cloud is still “coming soon”.

Conclusion

Try it now on the no-cost tier: developers building agents with many repeated micro-decisions, and teams wanting to cut cost and latency at the routing step. Wait if your team needs Google Cloud, a production SLA, or an independent benchmark.

Next step: prototype one small use case — ticket routing or output scoring — with all three question types, measure the fallback rate and real cost, then scale up. Keep a rollback path ready: a feature flag to turn Decisions API off and go back to calling an LLM directly.

Lessons learned

1. Separate deciding from generating text: most decisions inside an agent are closed-set.
2. Confidence is a feature, not metadata: without thresholds and fallback, a decision model is just a faster classifier.
3. Batching decisions into one request is cheaper than calling them one by one — but one bad input skews the whole batch, so split batches by independent failure unit.
4. A vendor’s benchmark is not an independent result: use it for direction, not for “most accurate” claims.
5. The v1beta endpoint and Cloud “coming soon” mean you can prototype now, but production needs a fallback layer behind a feature flag.

Verification scope

Checked on 12/11/2026. Verified against Google’s official announcement of 11/11/2026 and independent reports that agree with it (InfoWorld, SiliconANGLE, Economic Times). Verified: launch date, model, v1beta endpoint, the three question types, the 1,000-question and 256K-token limits, latency and pricing per Google, the official Python sample, and the google-genai 3.2+ SDK requirement. The “benchmark leader”, “nearly 5x cheaper”, and “up to 40% lower latency” claims are Google’s own figures, not independently verified. The API was not run live: this article follows the official documentation and does not claim installation or measured latency or real cost.

References

• Google — Gemini Decisions API (11/11/2026): https://blog.google/innovation-and-ai/technology/developers-tools/gemini-decisions-api/
• Google AI Studio — Decisions API documentation: https://aistudio.google.com/docs/decisions-api
• InfoWorld — Gemini Decisions API handles up to 1,000 questions per request: https://www.infoworld.com/article/4247774/googles-gemini-decisions-api-to-handle-up-to-1000-questions-per-request.html
• SiliconANGLE — Google enters the decision-model market: https://siliconangle.com/2026/11/11/google-enters-the-decision-model-market-with-gemini-decisions-api/
• Economic Times — Why Google and OpenAI want AI agents to decide faster: https://economictimes.indiatimes.com/ai/ai-insights/why-google-and-openai-want-ai-agents-to-decide-faster/articleshow/135760675.cms
• Pivot News — Google launches Gemini Decisions API: https://pivotnews.ai/five/google-launches-gemini-decisions-api-for-fast-bounded
• AI Weekly — Gemini Decisions API at $0.10 per 1M tokens: https://aiweekly.co/alerts/google-launches-gemini-decisions-api-at-010-per-1m-tokens