Google launches Gemini Decision 1: up to 1,000 scored questions per call, $0.10/M input tokens, and zero output cost
🔎 A model that generates absolutely nothing — and that's exactly the point
On November 11, 2026, Google quietly added an unusual object to its Gemini API: an AI model that doesn't produce a single text token. Gemini Decision 1 (gemini-decision-1), available in the Gemini API (v1beta) and AI Studio, doesn't write, doesn't converse, doesn't explain itself. It scores. Up to 1,000 questions per call, returning calibrated probabilities rather than paragraphs.
The launch, notably reported by TestingCatalog, is part of a trend the industry has only just formalized: since September 2026, an entire category — "decision models" — has taken shape before our eyes. TypeSafe kicked things off with Jev, Microsoft followed, OpenAI deployed its Decisions API on October 22. Google arrives fourth. But with a weapon the first three don't have: distribution.
The heart of the problem comes down to one sentence. An agent pipeline spends the bulk of its tokens making micro-decisions — routing a request, validating a policy, scoring a response. Paying generation prices to get a "yes" or a "no" was an economic absurdity. Four players have gone after this cost line in three months. Google has just thrown its full weight behind it. Here's what changes, with the numbers to back it up.
Key Takeaways
- A scoring model, not a generation model: no token-by-token decoding, but scoring in a single forward pass — median latency of 50-100 ms of model compute, 150-250 ms end to end.
- 1,000 questions per call on a shared multimodal input (text, images, audio, video, PDF) up to 262,144 tokens (256K). Three formats: noul (probabilistic yes/no), choice (2-255 options), score (2-255-level rubric), plus a 0-1 confidence score.
- $0.10/M input tokens, zero output (November 2026): the shared input is billed only once per request, with no charges for thinking, transcription, or OCR. Google claims ~5x cheaper than Gemini 3.5 Flash-Lite via the Interactions API.
- 92.2% on JevBench, the best score on the market ahead of GPT-6 Luna (90.9%) and Jev 1.14 (90.0%) — but beaten on When2Call and Mind2Web Multimodal.
- Remarkable calibration: Top-1 ECE error of 0.0250, roughly two times lower than Jev 1.14's (0.0494).
- Acknowledged limitations: no caching or Batch API at launch, Google-exclusive hosting, google-genai SDK 3.2+ required.
Recommended tools
The decision models market is new but already structured. Four players, four positioning strategies, two price tiers:
| Model | Accepted input | Price (November 2026) | Ideal for |
|---|---|---|---|
| Gemini Decision 1 | Text, images, audio, video, PDF (256K) | $0.10/M input, output free | Large-scale multimodal evaluation, audio/video guardrails |
| OpenAI Decisions API | Text + images | $0.10/M | Teams already anchored in the OpenAI ecosystem |
| Jev (TypeSafe) | Text only | $0.042/M | Massive text classification, minimal budget |
| Microsoft-Decision-1 | Text only | $0.042/M | Azure pipelines, pure text workloads |
Prices recorded on November 12, 2026 via CellCog, which maintains the most comprehensive comparison table in the segment (9 benchmarks) — check the official websites before committing to anything.
On the access side: AI Studio for prototyping, OpenRouter and the Vercel AI Gateway (AI SDK 7, which handles audio, video, and PDF) in production, with LangChain integrations currently rolling out according to The Decoder.
Gemini Decision 1: What Exactly Is It?
Straight answer: a classification model that replaces autoregressive decoding with a single forward pass. You send it a multimodal context and a batch of questions; it returns probabilities, never text.
The principle deserves a closer look, because it inverts the logic of classic LLMs. A generative model reads your prompt, then writes its response token by token — every token costs compute, latency, and money. Gemini Decision 1 encodes the input once, then scores all the questions in parallel against that representation. The result: 50 to 100 ms of model compute on median, 150 to 250 ms end to end, with a nearly flat curve from 1 to 100 questions as long as the input stays under 16K tokens.
On the input side, a shared context of 262,144 tokens accepts text, images, audio, video, and PDFs. On the output side, three strictly delimited formats:
- noul — the yes/no question, with a probability deliberately bounded between 0.01 and 0.99. The model is never allowed to be absolutely certain: a design choice that prevents misleading certainties and pushes uncertainty into your thresholds.
- choice — 2 to 255 options, with normalized probabilities. The routing format: "which category?", "which tool to call?", "which sub-agent?".
- score — an ordered rubric of 2 to 255 levels. The grading format: "rate this response out of 10", "assess severity from 1 to 5".
Each response comes with a confidence score between 0 and 1, designed to route ambiguous cases to a fallback or human review. It's this probability + confidence pairing that drives the system's operational value — not raw accuracy.
The endpoint is part of Google's in-depth overhaul of its developer stack: after the general availability of the Interactions API, the new default interface for building Gemini agents, Decision 1 arrives as a specialized building block in v1beta. You need the google-genai SDK 3.2+ at minimum.
My take: the real innovation isn't the model, it's the output contract. The JSON schemas imposed on generative LLMs were a band-aid — fragile parsing, format hallucinations, costly retries. Here, the interface is the product. Probabilistic classification should finally move beyond the hacks.
The economics: $0.10/M input, zero output
The direct answer: the nominal rate of $0.10/M tokens is identical to OpenAI's — but it's the billing structure that makes the difference, not the advertised price.
First pillar: no output tokens are billed, simply because there are none. No decoding, no thinking fees, no transcription or OCR. Audio and video go straight into the model. For a pipeline that handles audio, this is a detail that changes everything: where you would otherwise have to pay for an STT step upstream — Google, for its part, promotes its Gemini 3.5 Transcribe, 85 languages at 2.6% WER engine for this kind of task — Decision 1 swallows the raw audio without an extra line on the invoice.
Second pillar, the most important one: shared input is billed once per request, no matter how many questions. Twenty checks run against the same 4,000-token transcript cost 4,000 billed tokens, not 80,000.
VentureBeat's worked example gives the exact figure: a 4,000-token recording + 20 checks of 50 tokens ≈ 5,000 tokens, or roughly $0.50 for 1,000 recordings in a single request — versus $8.10 for 1,000 in 20 separate calls. A 16x factor, obtained purely by changing the shape of the call.
Google also claims ~5x cheaper than Gemini 3.5 Flash-Lite via the Interactions API across its benchmark suite. VentureBeat's cross-check: $0.88 for the full suite on Decision 1, versus $4.14 for Flash-Lite — i.e., 4.7x, consistent with the claim. But a nuance is in order: Jev 1.14 runs the same suite for $0.68. On pure text, Google isn't the cheapest on the market. It's the cheapest in multimodal — a category of which it is, for now, the sole member.
To test without a credit card: the free tier offers 200 requests and 50,000 input tokens per minute. Plenty for prototyping an evaluation or a router. This kind of offer is featured in our roundup of free AI APIs, updated regularly.
Benchmarks: leader on 7 of 9 tests, but two agentic gaps
Direct answer: Gemini Decision 1 leads on 7 of the 9 accuracy tests in the launch table, including JevBench at 92.2% — but it loses precisely on the two benchmarks closest to agentic use.
The official figures, as reported by VentureBeat and CellCog:
| Benchmark | Gemini Decision 1 | Jev 1.14 | GPT-6 Luna | Gemini 3.5 Flash-Lite |
|---|---|---|---|---|
| JevBench | 92.2% | 90.0% | 90.9% | 86.6% |
| When2Call | 79.9% | 82.0% | — | — |
| Mind2Web Multimodal | 86.2% | 86.8% | — | — |
| MMAU (audio) | 71.8% | — | — | — |
| Video-MME | 69.1% | — | — | — |
| Amazon ESCI (Macro-F1) | 58.7% | — | — | — |
"—": score not published at launch. Source: Google launch table, aggregated by CellCog.
Three takeaways. The victory on JevBench — 92.2% versus 90.9% for OpenAI's GPT-6 Luna and 90.0% for Jev 1.14 — is real but narrow: a 1.3-point gap with the runner-up. The multimodal superiority, on the other hand, is clear-cut: 71.8% on MMAU in audio, 69.1% on Video-MME. No one else in this market scores video.
The two losses deserve more attention than the seven wins. When2Call (79.9% versus 82.0% for Jev 1.14) measures exactly the ability to decide when to call a tool — the core of agent routing. Mind2Web Multimodal (86.2% versus 86.8%) tests web navigation. If your main use case is tool selection, TypeSafe's model remains ahead, at an input price 2.4x lower.
Another underplayed signal: calibration. The Top-1 ECE error of Gemini Decision 1 stands at 0.0250, roughly half that of Jev 1.14 (0.0494). In concrete terms: when the model displays 0.85 confidence, it is statistically right about 85% of the time. If you build automation thresholds on these probabilities — above 0.95 you automate, below you route to a human — this is the metric that matters more than accuracy.
Finally, the absolute weak point: Amazon ESCI at 58.7% Macro-F1, its worst score. If your task resembles e-commerce relevance, proceed with caution.
And where does Flash-Lite fit in all this? At 86.6% on JevBench, it illustrates the limits of a generalist LLM diverted from its primary purpose to do scoring. Google knows this better than anyone: the lineup is specializing, on the heavy-generation side as shown by the feature Gemini 3.5 Pro, 2 million tokens and the Deep Think mode, and on the scoring side with Decision 1. Two lineups, two use cases, two cost structures.
The "model as judge" market: fourth to arrive, best distribution
Direct answer: Google didn't invent the decision models category — it's standardizing it and distributing it at a scale nobody else can even aim for.
The timeline tells the whole story. September 2026: TypeSafe launches Jev (0.042 $/M, text-only), Microsoft files Microsoft-Decision-1 (0.042 $/M, text). October 22: OpenAI opens its Decisions API (0.10 $/M, text + images). November 11: Gemini Decision 1 (0.10 $/M, fully multimodal). Four models in three months: the segment has gone from experimentation to a positioning war.
Like the The Decoder framework, the wave targets "model as judge" and agent micro-decisions: routing, policy checks, tool selection, grading. In other words, the layer of the AI stack that nobody sees but that runs billions of times a day — and which, until now, was billed at generation prices.
Google's answer boils down to three asymmetries. Multimodality first: the only player to natively cover both audio and video. Distribution next: AI Studio, OpenRouter, Vercel AI Gateway, and LangChain from day one, while Jev and Microsoft-Decision-1 remain niche offerings. And finally, dogfooding: Google is already using Decision 1 internally for dynamic routing in Gemini Notebook, design prototyping in Stitch, and safety checks for Google Search. When a model serves as a guardrail for Google Search, its industrialization is no longer a working hypothesis.
My bet: the war won't be fought on accuracy — the gaps are measured in 1 to 2 points — but on calibration and integrations. That's exactly the terrain where Google arrives with a ten-year cultural head start over brilliant challengers who face their ecosystem alone.
Routing, guardrails, evaluation: the three use cases that make sense
Direct answer: three uses justify a decision model today — routing agents, applying guardrails at every step, and evaluating continuously. The rest is still marketing.
Routing agents without breaking the bank
Every handoff in a multi-agent architecture is a decision: which tool, which sub-agent, what priority. With a single Decision 1 call, you ask "which tool?", "is this action allowed?" and "is the user showing frustration?" over the same context, billed once. For distributed swarm-style architectures, where an orchestrator drives dozens of workers, a micro-decision layer at 150-250 ms and a few tenths of a cent changes the entire economic equation. We detail these patterns in our guide to the best LLMs for AI agents; and to see where Google is pushing heavy orchestration, our article on Gemini 4 Carbon and its Swarm framework for orchestrating agent swarms shows how the two layers complement each other: Carbon reasons and plans, Decision 1 arbitrates at low cost.
Guardrails that run on every request
Policy checks, PII detection, moderation: classic guardrails are so expensive that they get applied through sampling — 1% of traffic, one day in seven. At $0.50 per 1,000 checks, you apply them to 100% of traffic, in real time. That's exactly the use Google makes of them internally on Search, and the confidence score means only the genuinely ambiguous cases get sent to human review. The guardrail stops being a budget compromise and becomes a systematic property of the system.
Continuous evaluation, finally affordable
LLM-as-judge has been around for two years. The problem was never the technique but the cost: overnight runs over thousands of samples, with output tokens billed at full price to produce one-line verdicts. With the score format — rubrics with up to 255 levels — and input-only billing, a daily regression suite over 10,000 responses becomes a negligible budget line. On one imperative condition: calibrate your judge on your own data before automating anything. See the mistakes below.
The limitations to know before you sign
Direct answer: three technical limitations belong in your cost calculations, and one strategic limitation belongs in your thinking as an architect.
No caching, no Batch API. Repeated context is billed in full on every call, according to MarkTechPost. If your pipeline resends the same 100K-token document with different questions from one call to the next, the bill explodes and the pricing advantage evaporates. Google's answer is baked into the design: batch all your questions into a single call, up to 1,000. Beyond that, or beyond 256K tokens, you're back to full-rate billing, with no safety net.
Google hosting only. No open weights, no self-hosting, no VPC deployment. For regulated sectors — healthcare, finance, the public sector — this is potentially disqualifying, whatever the price.
Flat latency, under conditions. The 150-250 ms profile holds for inputs up to 16K tokens and batches of 1 to 100 questions. Beyond that, the curve steepens, and Google hasn't yet published guarantees for large batches over long contexts. Benchmark your actual workload shape before promising SLOs.
Finally, schema lock-in. The noul/choice/score types aren't a standard; they're Google's format. Migrating to OpenAI's Decisions API or to Jev means rewriting your evaluation suites. The schema is simple enough that an abstraction layer would cost little — but it doesn't exist yet, and someone will have to take on the risk of maintaining it.
❌ Common Mistakes
Mistake 1: Treating Decision 1 as just another LLM
What goes wrong: asking it for explanations, written-out reasoning, or content generation. The model doesn't produce any tokens — you'll get probabilities, not paragraphs.
The fix: keep a generative model for the 2% of cases that the confidence score flags as ambiguous, and route to it. Decision 1 sorts, the generative model decides. The two tools don't replace each other, they stack.
Mistake 2: Ignoring billing for repeated context
What goes wrong: replicating your generative call pattern — one call per question — with Decision 1. Without caching, you pay for the same context 20 times over and destroy the product's economic advantage.
The fix: one request = one context + every possible question about that context. Only split if you exceed 1,000 questions or 256K tokens, and then batch by context.
Mistake 3: Setting confidence thresholds without recalibrating on your own data
What goes wrong: treating the ECE of 0.0250 measured on Google's benchmarks as a universal guarantee. On your traffic distribution — your formats, your languages, your edge cases — calibration will be different, sometimes markedly so.
The fix: label a few hundred of your real cases, recalculate calibration locally, then set your automation thresholds. And keep in mind that probabilities are capped at 0.99: "almost certain" is the maximum available, never "certain".
Mistake 4: Comparing prices down to the token
What goes wrong: comparing $0.042/M (Jev) to $0.10/M (Google) and concluding that Jev is 2.4x cheaper. Across the full benchmark suite, the real gap is $0.68 vs $0.88, because final cost depends on input volume per decision, not the nominal rate.
The fix: always compare in terms of cost per 1,000 decisions on your real workload, output included when you're evaluating generative models.
❓ Frequently Asked Questions
Can Gemini Decision 1 generate text or justify its answers?
No. The model performs scoring in a single forward pass, without token-by-token decoding. It returns probabilities in the noul, choice, and score formats, along with a confidence score. For text or justifications, you need a generative model, ideally called as a fallback for ambiguous cases.
How much does a typical call cost in practice?
Using the VentureBeat example: a 4,000-token record plus 20 verifications of 50 tokens each represents about 5,000 tokens, i.e., ~$0.50 for 1,000 records in a single request, versus $8.10 with 20 separate calls. The shared input is billed only once, and the output is free.
Can you run it locally or with another hosting provider?
No. The API is hosted by Google only, with no open weights or self-hosting. It remains accessible via OpenRouter and the Vercel AI Gateway, but the compute stays with Google — a blocker for regulated environments or those with strict data sovereignty requirements.
What are the volume and context limits?
Up to 1,000 questions per call, within a shared context of 262,144 tokens split between the input and the questions. Latency remains nearly flat up to 100 questions for 16K-token inputs. On the free tier: 200 requests and 50,000 input tokens per minute — enough to prototype seriously.
How do you choose among the four decision models on the market?
In three questions. Need audio or video? Then Gemini Decision 1, the only one with full multimodality. Tight budget for pure text? Jev or Microsoft-Decision-1 at $0.042/M. Already invested in Azure or OpenAI? Their respective APIs. The accuracy gaps are small; the price and integration gaps are considerable.
✅ Conclusion
Gemini Decision 1 will never replace your generative LLM — it frees it from the thousands of micro-decisions for which it was outrageously too expensive, and that's precisely what the agent industry has been waiting for. Try the free tier (200 requests/minute) today, and if you're building agentic pipelines, cross-reference this choice with our comparison of the best LLMs for AI agents and our monthly comparison of the best LLMs.