Google shipped an AI model that refuses to generate text — and that’s exactly what makes it useful. The Gemini Decisions API, launched November 11, introduces gemini-decision-1: a model that scores up to 1,000 yes/no, multiple-choice, or rubric questions in one forward pass. No prose. No token-by-token generation. Just structured scores with confidence values, returned in 150–250ms. If you’re building AI agents, this is worth understanding.
What It Actually Does
The core mechanic is simple to describe, harder to appreciate until you’ve hit the routing cost problem: you send one shared input — text, images, audio, video, or PDFs up to 256K tokens — along with up to 1,000 independent questions. The model scores every question in a single pass and returns typed responses with confidence scores from 0.0 to 1.0. Zero output tokens billed.
Three question types are supported:
- noul — yes/no checks (e.g., “Is the customer asking for a refund?”)
- choice — pick one from labeled criteria (e.g., “Which team handles this — billing, shipping, or general?”)
- score — ordered rubric grading (e.g., “How urgent is this message? Not urgent / Reply today / Reply now”)
A minimal Python example from Google’s docs makes the pattern concrete:
from google import genai
client = genai.Client(http_options={"api_version": "v1beta"})
result = client.decisions.create(
model="gemini-decision-1",
input=[{"type": "text", "text": "I was charged twice. Please refund one."}],
questions={
"wants_refund": {
"type": "noul",
"instructions": "Is the customer asking for a refund?",
},
"team": {
"type": "choice",
"instructions": "Which team should handle this?",
"criteria": {
"billing": "Payments, refunds, invoices.",
"shipping": "Delivery, tracking, damaged parcels.",
"general": "Anything else.",
},
},
"urgency": {
"type": "score",
"instructions": "How urgent is this message?",
"criteria": ["Not urgent.", "Needs a reply today.", "Needs a reply now."],
},
},
)
Three decisions. One API call. No prompt asking an LLM to “think step by step” about which team to route to.
The Problem It Solves
If you’ve built an AI agent with any routing logic, you’ve probably done something like this: sent a question to a generative model, parsed its text response, and hoped it said “billing” or “shipping” rather than “I think this would best be handled by the billing department, as the customer’s concern relates to…”. Using a generative LLM for bounded decisions is the wrong tool for the job. It’s slow (500–2,000ms per call), it burns output tokens, and it requires fragile output parsing.
Industry data backs this up: teams commonly overpay 40–85% on AI costs by running full generative models for simple routing decisions. According to VentureBeat, Google’s own Gemini Notebook team reports 40% lower latency after switching to Decision 1 for query-to-model-tier routing. That’s not a marginal improvement — that’s a rearchitecting win.
The confidence scores matter here too. A score of 0.73 on a “choice” question isn’t a confident answer — your code can automatically route that case to a fallback or a human reviewer without any prompt engineering for uncertainty.
Pricing and How It Compares
Gemini Decision 1 costs $0.10 per million input tokens with zero output charges. No output tokens means the pricing model is fundamentally different from generative APIs — you’re paying for context understanding, not text production.
The direct competitor is GPT-6 Luna Decisions:
| Feature | Gemini Decision 1 | GPT-6 Luna Decisions |
|---|---|---|
| Max questions/request | 1,000 | 200 |
| Input price | $0.10/M tokens | $0.10/M tokens |
| Output price | $0 (no output) | $0.50/M tokens |
| End-to-end latency | 150–250ms | ~230ms |
| Context caching | Not supported | Supported |
| Multimodal | Yes | Yes |
On benchmarks, Gemini Decision 1 scores 92.2% on JevBench versus GPT-6 Luna’s 90.9%. At the same input price, 5x more questions per request and no output charges make it the stronger default for new projects. OpenAI’s context caching can flip the math on repeated long inputs — but that’s a specific workload pattern, not the common case.
Limitations Worth Knowing
The lack of context caching is the real limitation. If your pipeline sends the same large PDF to Decision 1 in multiple separate requests, you pay full input tokens each time. The Batch API is also unsupported. YouTube URLs and direct Google Cloud Storage URIs aren’t accepted — only direct file uploads. And free tier inputs may be used to improve Google’s models, so keep sensitive data off the free tier.
Available Now
The API is live in Google AI Studio with a free tier (10,000 requests/day, 200 RPM). The official launch post includes Python, JavaScript, and REST guides. Integrations are live across OpenRouter, LangChain, Vercel AI SDK, LiteLLM, Pydantic AI, and LiveKit. Google Cloud support is listed as coming soon.
The trend is clear: purpose-built decision APIs are becoming a recognized primitive alongside text generation APIs. Microsoft has Decision-1, OpenAI has GPT-6 Luna Decisions, and now Google has this. The generative LLM is the wrong hammer for every nail — and the industry is finally building the right tools for bounded decisions.
