Google's Gemini Decision 1 Answers 1,000 Questions in One API Call

Google shipped a model yesterday that doesn't write anything. That's the whole point.

Gemini Decision 1 — announced November 11, 2026, in a blog post by Google DeepMind's Min Choi and Felix Yu — is a decision-only model. You hand it one input and up to 1,000 questions, and it scores every option in a single forward pass. No tokens generated, no prose, no "let me think about that." Just probabilities and a confidence score, back in 150–250 milliseconds.

If you've built an agent that burns a full LLM call every time it needs to pick a tool, check a policy, or grade a chunk of context, this is the kind of endpoint that quietly rewrites your cost math. I haven't tested it hands-on yet — nobody outside Google had access before yesterday — so this is a docs-verified breakdown of the launch, not a war story. Here's what it actually does, what it costs, and where the launch numbers get less flattering.

What it is

Most of your agent's LLM calls aren't really generation. They're judgments wearing a generation costume: which tool should run, is this output safe to show, which model should handle this query, how good is this retrieved chunk. Each one costs you a full decode — tokens out, latency, money — for an answer that could have been a number.

The Decisions API strips that down. One request carries a shared multimodal input — text, image, audio, video, PDF, up to 256K tokens — plus 1 to 1,000 independent questions. Three question types:

• noul (yes/no): probability a condition holds, with optional true/false criteria
• choice (multiple choice): 2 to 255 options, returns the winner plus normalized probabilities for every candidate
• score (ordered rubric): grades an input on a rubric starting at 0, returns a continuous weighted score plus per-level probabilities

Every answer includes a confidence score from 0 to 1, so your code can route the ambiguous ones to a fallback or a human. The shared input is billed once per request no matter how many questions you ask — each question only adds its own instruction and criteria tokens.

The endpoint is POST https://generativelanguage.googleapis.com/v1beta/decisions with x-goog-api-key auth, or client.decisions.create in the google-genai SDK (3.2+). It's live in the Gemini API and Google AI Studio. Integrations are rolling out across OpenRouter, LangChain, Vercel AI SDK, LiteLLM, Pydantic AI, Pipecat, LiveKit, and OpenCode.

Google's own example is a breakroom counter photo checked against all three question types in one call — is there a spill, which cleanup action fits, how severe is it:

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.",
        ]},
    },
)

The price is the real story

$0.10 per million input tokens. $0 for output — because there is none. There's a no-cost tier in AI Studio for prototyping.

Google says that's nearly 5x cheaper across its shared benchmark suite than Gemini 3.5 Flash-Lite with the Interactions API. That's Google's claim, on Google's suite — but the direction is right. The expensive part of a judgment call was never the input. It was paying for a model to think out loud in tokens you didn't need.

Do the math on your own stack: if your agent makes 20 judgment calls per task and each one currently costs you a 200-token generation, Decision 1 collapses that to one scored pass. The latency claim is the other half of it — 50–100 ms of model compute, 150–250 ms end-to-end, nearly flat from 1 to 100 questions per request, at contexts up to 16K tokens. That's the number that makes it usable as a control plane, not just a batch scorer.

The benchmarks, and the asterisks on them

Google's launch table compares Decision 1 against TypeSafe Jev 1.14, OpenAI's GPT-6 Luna (via the OpenAI Decisions API), and Gemini 3.5 Flash-Lite across nine benchmarks. Decision 1 leads 7 of the 9 — and 5 of the 7 tests that all four models ran.

The headline numbers, all Google's own:

The calibration gap is the most interesting number in the table. A calibration error of 0.0250 — roughly half of Jev's 0.0494 — means when the model says it's 80% sure, it's right about 80% of the time. That's what makes confidence scores usable as routing logic instead of decoration. If you're building human-escalation rules on top of this, calibration matters more than raw accuracy.

But Google lost two of the nine, and those two are worth naming: Jev beats Decision 1 on Mind2Web Multimodal (86.8% vs 86.2%) and on When2Call, the test of knowing when to invoke a tool (82.0% vs 79.9%).

And the independent scoreboard is less flattering still. The Artificial Analysis Decision Index v2.1 puts Gemini Decision 1 ninth of 18 at launch, with a score of 65.98 — just behind Jev 1.14 at 66.23, and well behind Drex Max v1.1 at 72.62. On the index's AA-Paperclip test, which requires correctly understanding entire documents, only 33% of documents were answered completely correctly, versus 63% for Drex Max.

So the honest read: Google's model is very good at the benchmarks Google chose, genuinely well-calibrated, and merely mid-pack on the one independent index that exists. Both things are true at once.

Google is late, and it knows it

This is a race Google is joining, not leading. OpenAI's Decisions API went generally available on October 22 with GPT-6 Luna. Amazon shipped Strands Decider 2B in October. TypeSafe's Jev arrived in September. Microsoft has Decision-1 too. Every major lab now has a model that judges instead of writes.

Google's counter is that it's already dogfooding it: Gemini Notebook uses the Decisions API as a real-time router, directing queries to the right model tier and thinking level, with up to 40% lower latency on everyday queries. Google Search uses it as a safety layer for MCP tools. Stitch's rapid canvas experiment uses it to generate playable wireframes. CC from Google Labs uses it to pick emoji reactions from a 200+ palette in a fraction of a second. Those are real internal deployments, not demo slides — and the Notebook one is the most telling, because routing is exactly the job this model exists for.

It also landed a day after Gemini 4 Carbon went generally available to paying users. Google is shipping fast right now. That doesn't make each launch good, but the pace itself is the context.

The catches

There are a few, and they're the kind that decide whether you adopt this week or wait:

• No Vertex AI yet. It's Gemini API and AI Studio only, with Google Cloud support "coming soon" and no date attached. If your stack is Vertex-only, you're waiting.
• No reasoning trace, no prose. The model returns scores, not explanations. When it's wrong, you get a wrong number with a confident face. Your fallback logic has to carry that.
• The latency number has a ceiling. The 150–250 ms figure holds at contexts up to 16K tokens and up to 100 questions. A full 256K-token input with 1,000 questions is a different workload, and Google hasn't published numbers for that corner.
• The free tier is for prototyping. Fine for trying it. Read the data-use terms before sending anything sensitive through a no-cost tier.
• The benchmarks are Google's. The JevBench lead and the calibration gap come from Google's own table, where refusals and unsupported inputs count as incorrect. The independent index says ninth of eighteen. Run your own eval before you believe either scoreboard.

What I'd actually do

If you run agents in production, the use cases that justify trying this today are narrow and concrete: tool selection, policy checks, model routing, context grading — the small judgments your agent makes dozens of times per task. That's where a 200 ms scored call at $0.10 per million tokens replaces a full generation, and the savings compound.

Don't rip out your existing router this week. Do this instead: pick one judgment in your agent loop — the one you already have labeled data for — and run Decision 1 against your current approach for a day. The calibration number is the thing to check, not the accuracy. If the confidence scores track reality on your data, you have a router. If they don't, you have a launch-day benchmark.

And if you're on Vertex AI, or you need the model to explain itself, this isn't your launch. Wait for the Cloud support date and watch whether the independent index moves.

Have you wired a decision model into an agent loop yet — Jev, GPT-6 Luna, or now Decision 1? I'm curious which judgment you handed off first, and whether the confidence scores held up on your data.

Sources: Google blog, "Gemini Decisions API: Fast, calibrated multimodal decisions" (Nov 11, 2026); VentureBeat, "Google's Gemini Decision 1 model scores up to 1,000 questions in one API call" (Nov 11, 2026); Artificial Analysis Decision Index v2.1 as reported by VentureBeat. Benchmark figures are Google's own except where the independent index is cited.