How to Use Google’s Gemini Decisions API: 1,000 Decisions in One Call

Google launched the Gemini Decisions API on 11 November 2026, and it does something no Gemini model has done before: it answers without writing a word. Instead of generating text token by token, the new Gemini Decision 1 model (gemini-decision-1) reads one shared input and scores up to 1,000 closed questions about it in a single pass, returning a probability and a confidence score for each one. Google says the whole round trip takes 150–250 milliseconds and costs $0.10 per million input tokens, with zero output tokens billed — because there is no output text at all. This guide shows how to set it up, what the three question types do, what it costs, and the first three jobs worth trying it on.

Quick answer: Google's Gemini Decisions API scores up to 1,000 yes/no, choice or rubric questions in one call for $0.10 per million input tokens. Setup, costs and first jobs.

What Is the Gemini Decisions API?

The Decisions API is a purpose-built endpoint for bounded choices, not open-ended chat. Google’s announcement, written by DeepMind product manager Min Choi and principal scientist Felix Yu, describes it as a set of primitives for jobs like tool selection, policy checks, model routing and context grading — the small yes/no, pick-one and grade-it decisions that sit inside bigger AI systems. You send one multimodal input — text, images, audio, video or a PDF, up to 256K tokens — plus a list of questions, and the model scores every candidate answer in one forward pass.

It is available now through the Gemini API in Google AI Studio, on the v1beta endpoint. Support for Gemini in Google Cloud (Vertex AI) is listed as “coming soon”, so for now it runs on the Developer API only, with integrations rolling out across OpenRouter, LangChain, Vercel AI SDK, LiteLLM and others. It is not a new chat model, and it cannot be called through the ordinary text-generation path — a point worth absorbing before you redesign anything around it.

Google is not alone here. OpenAI launched its own Decisions API at DevDay on 29 September 2026, and Microsoft shipped Microsoft-Decision-1 on its Foundry platform on 8 October. Google’s entry is the multimodal-first one: a single input can mix a call recording with account metadata, or a scanned PDF claim with damage photos, and one request can carry a thousand questions about that shared material.

How It Works: One Input, 1,000 Questions

One request carries one shared input and between 1 and 1,000 independent questions, all bounded by a 262,144-token context window that the input and every question share. The model scores the fixed options for each question rather than decoding an answer, and every answer comes back with a confidence score from 0 to 1, so your code can route ambiguous cases to a fallback or a human reviewer instead of acting on a guess.

Google’s latency figures are 150–250 ms end to end, with 50–100 ms of median model compute, and Google says latency stays nearly flat from 1 to 100 questions per request. One honest caveat: those measurements cover multimodal contexts up to 16K tokens. Google has not published the same flat-latency claim for a full 1,000-question request at the 256K-token ceiling, so treat the headline speed as proven for ordinary workloads, not for the maximum configuration.

The billing is the part that changes the maths. 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. There are no output-token charges, no variable thinking-token bills, and no separate audio-transcription or OCR costs, because the model never generates text.

The Three Question Types: noul, choice and score

Every question is one of three types, and picking the right type is most of the skill. Google’s own worked example checks a photo of a breakroom counter against all three at once:

Type What it does Example from Google’s own demo
noul (yes/no) Estimates the probability that a yes/no condition holds, with optional true and false descriptions. “Is there an uncleaned liquid spill on the counter?”
choice (multiple choice) Selects from 2 to 255 options, returning the winner and normalised probabilities for every candidate. “Which cleanup action fits the scene?” — wipe with cloth, dispatch janitorial, or ready for meeting.
score (ordered rubric) Grades the input across an ordered rubric starting at 0, returning a continuous weighted score and per-level probabilities. “Rate the severity of the counter mess” on a three-level rubric from clean to safety hazard.

The design rule is simple: use noul for checks, choice for routing, and score for grading. A support ticket can be triaged with one noul (“is this urgent?”), one choice (“which team owns it?”) and one score (“how complete is the description?”) — three answers, one request, one shared input.

How to Make Your First Decisions API Call in 5 Steps

Step 1: Get an API key in Google AI Studio. Sign in, create a key, and you can start on the no-cost tier with no billing account. Remember the trade-off: Google says it may use free-tier inputs to improve its products, while paid-tier inputs are not used that way — so keep sensitive customer records off the free tier.

Step 2: Install the google-genai SDK. Google publishes Python, JavaScript and REST guides in the Decisions API documentation. The Python path is pip install google-genai; JavaScript developers need @google/genai 3.2 or later.

Step 3: Point at the model. Use model id gemini-decision-1 on the v1beta API version, and call the Decisions endpoint (client.decisions.create in the SDK), not the text-generation endpoint.

Step 4: Build one shared input and your questions. Adapt Google’s own breakroom example — a photo plus a short text note, checked against all three question types in one 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://example.com/counter.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 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 localised spill.",
                         "Major spill or safety hazard."],
        },
    },
)

Step 5: Read the probabilities, not just the winner. The response gives you a winning option and a probability for every candidate. Set a confidence threshold — for example, anything below 0.70 goes to a human reviewer — and log the scores so you can see where the model is consistently unsure. A decision API without a threshold is just a faster way to be wrong with confidence.

What Does the Gemini Decisions API Cost?

Input-only pricing: $0.10 per million input tokens on the paid tier, $0 for output, and a free tier for prototyping. The limits, read from Google’s pricing and rate-limits pages on 12 November 2026:

Free tier Paid (Tier 1)
Input price Free $0.10 per 1M tokens
Output price $0 $0
Requests per minute 200 1,500
Tokens per minute 50,000 1,000,000
Requests per day 10,000 50,000
Data use Google may use inputs to improve its products Not used for product improvement

The worked example makes the pitch concrete. VentureBeat ran Google’s numbers on a 5,000-token record with 20 checks: about $0.50 per 1,000 records through the Decisions API, against about $8.10 per 1,000 records for twenty separate generative calls that each re-send the record — before retries. That gap is the whole product: you pay once for the evidence, not once per question. (Google also claims it is nearly five times cheaper than Gemini 3.5 Flash-Lite with the Interactions API across its own benchmark suite — Google’s own claim, no independent test behind it.)

Three Jobs to Try First

1. Triage. The most immediate job is a support inbox or a claims queue: one shared ticket, a handful of noul and choice questions, and the confidence score decides whether the case routes automatically or waits for a person. Start with ten tickets and check the model’s calls against a human’s before you let it route anything live.

2. Routing. This is the job Google itself uses the API for. Gemini Notebook uses the Decisions API as a real-time router, directing everyday queries to cheaper model tiers and reserving deep-reasoning models for hard ones — Google says with up to 40% lower latency. If your app already calls more than one model, a single routing question (“which tier should handle this?”) can replace a chain of heuristic rules.

3. Scoring. Grade generated content or incoming context against a rubric: policy checks on tool calls, context grading for retrieval, or a safety layer that screens tool behaviour. Google says its Search team uses the API to detect adversarial behaviour. A rubric with three or four levels and a confidence threshold is a workable first version — add levels only when the scores show you need them.

When NOT to Use the Decisions API

If you need words out, this is the wrong tool. Summaries, drafts, chat replies and explanations all need a generative model; Gemini Decision 1 returns scores, not sentences. If you need memory or a conversation, look elsewhere too: context caching, the Batch API, Flex and Priority inference are all unavailable, and there is no conversation history.

If your organisation runs only on Google Cloud, wait: Vertex AI support is “coming soon” and the API is Developer-API-only today. And if the input is a whole document and every answer must be right, be careful — the independent tests below show whole-document accuracy is exactly where this model is weakest. Finally, never let a low-confidence answer act on its own. A probability of 0.52 is the model telling you it does not know; build the human fallback first, not after the first bad call.

What the Independent Tests Say

Two scoreboards, two stories — and both are worth reading. On Google’s own benchmark suite, the model leads across agent routing, reasoning, ranking and multimodal understanding with the lowest calibration error. Google reports 92.2% on JevBench against 90.9% for GPT-6 Luna and 90.0% for Jev 1.14, and a calibration error of 0.0250 against Jev’s 0.0494. Those are Google’s numbers, from Google’s tests, and Google’s launch post itself gives no numeric scores — the figures come via secondary reporting of Google’s comparisons.

The independent reading is cooler. Artificial Analysis’s Decision Index v2.1, published the same day, scores Gemini Decision 1 at 66, ninth of eighteen decision models. It is first on knowledge and hallucination resistance (AA-Omniscience 66.3) and first on multi-choice exam questions (HLE-MultiChoice 48.7) — but on AA-Paperclip, the document-decision test that carries 30% of the index, it scores 56.8 and answers only 33% of whole documents fully correctly, against 63% for the leader, Drex Max v1.1. Artificial Analysis also measures a median task latency of 211 ms and a cost of about $345 per million finished tasks on its own costing — a different measurement from Google’s per-token price, so do not compare the two numbers directly.

The honest verdict: strong where the job is scoring knowledge, routing a request or answering a narrow question, mid-table where the job is reading a whole document and getting every question about it right. That matches the design — a fast scorer, not a careful reader.

Our Take: The Three-Question Test

Before you adopt the Decisions API, ask three questions about the job itself. Is the answer a closed set — yes/no, a fixed list of options, a rubric? Can you act on a probability rather than a paragraph? And is a wrong answer cheap enough that a confidence threshold plus a human fallback can absorb it? If the answer is yes to all three, this API replaces a pile of generative calls with one cheap scored call, and the $0.50-per-thousand-records maths above is real money. If any answer is no, keep the generative model and spend the savings elsewhere.

Start on the free tier — 200 requests a minute and 10,000 a day is generous for prototyping — and move to paid only when a real workload needs the higher limits and the data-use guarantee. The model will not write your answers for you. That is the point: for the first time, Google is selling judgement by the question instead of words by the token, and for triage, routing and scoring, judgement by the question is the cheaper unit.

Frequently Asked Questions

Is the Gemini Decisions API free?

Yes, within the free tier: 200 requests per minute, 50,000 tokens per minute and 10,000 requests per day, with no billing account needed. The catch is that Google may use free-tier inputs to improve its products, so keep sensitive data on the paid tier, which costs $0.10 per million input tokens.

Can Gemini Decision 1 write text?

No. It scores fixed options and returns probabilities and confidence scores. Its output is always zero tokens, which is why output is free — and why it cannot draft, summarise or chat.

How many questions can one request hold?

Between 1 and 1,000, bounded by the 262,144-token context window that the shared input and every question share. Google’s flat-latency claim covers 1 to 100 questions on contexts up to 16K tokens.

Is it available in Google Cloud (Vertex AI)?

Not yet. Google lists support for Gemini in Google Cloud as “coming soon”. Today it runs on the Gemini Developer API (v1beta) through Google AI Studio.

How is it different from OpenAI’s Decisions API?

OpenAI launched its Decisions API at DevDay on 29 September 2026, and Microsoft shipped Microsoft-Decision-1 on Foundry on 8 October. Google’s version is multimodal-first — text, image, audio, video and PDF in one shared input — with up to 1,000 questions per call. On the independent Artificial Analysis Decision Index, Gemini Decision 1 scores 66 (ninth of eighteen) and Microsoft-Decision-1 scores 62 (tenth).

Sources and Methodology

Sources: Google, “Gemini Decisions API: Fast multimodal decisions”, blog.google, 11 November 2026 (primary source for launch facts, latency, pricing, use cases and the code example); APIdog, “Gemini Decisions API: What Gemini Decision 1 Does, Pricing and How It Works”, 12 November 2026 (pricing and rate limits cross-checked against Google’s pricing and rate-limits pages); VentureBeat, “Google’s Gemini Decision 1 model scores up to 1,000 questions in one API call”, 12 November 2026 (worked cost example); OrcaRouter, “Gemini Decision 1: Ninth of 18, First Where It Matters Least”, 12 November 2026 (Artificial Analysis Decision Index v2.1 breakdown). Internal links: our Gemini 4 Carbon explainer, our Gemini Omni 1.2 Flash video guide, and our Google PLE engineering-exam explainer.

Method: desk research, verified 13 November 2026 against Google’s own announcement and secondary reporting. No hands-on API test was run for this article — no API key was used — so the setup steps and code example are adapted from Google’s own documentation and example, and are labelled as such. Google’s benchmark claims are labelled as Google’s own; independent figures are labelled as Artificial Analysis’s. No figure in this article was invented.

Leave a Reply

Your email address will not be published. Required fields are marked *