Back to Explore
NewsVibeFix editorialUpdated Nov 19, 2026

Google Joins the Decision-Model Race: Gemini Decisions API Lets a Model Judge Without Writing, 1,000 Questions in One Request

On November 11, Google launched the Gemini Decisions API with its Gemini Decision 1 model: instead of generating text, it answers up to 1,000 yes/no, choice, and rubric questions in a single pass, in 150-250 ms, at $0.10 per million input tokens with zero output tokens billed. Google is the fourth entrant in the decision-model race in three months.

Google blog hero image: a kitchen counter spill photo with Decisions API result cards (spill 0.95, wipe with cloth 98%, severity 1.19 out of 2).

The model stopped writing and took up judging instead

On November 11, Google announced the Gemini Decisions API on its official blog, together with a new model, Gemini Decision 1, model name gemini-decision-1. What makes this release unusual is not the size of the model but the job it does: this model does not generate text, it only makes judgments. You give it an input plus a set of questions, and instead of writing sentences or continuing paragraphs, it returns a probability and a confidence score for each question. In Google's words, the Decisions API offers primitives built for bounded choices, for use cases including tool selection, policy checks, model routing, and context grading. Put differently, Google has moved the model off writing duty and reassigned it as a referee.

The most eye-catching number in the announcement is how many questions one request can carry: up to 1,000. The input is a single shared multimodal payload — text, images, audio, video, and PDFs — capped at 256K tokens; the questions ride on top of that input, and all three types can be mixed in one request. A yes/no question is called noul: it estimates the probability that a condition holds, and you can attach true and false description criteria. A multiple-choice question is called choice: it picks from 2 to 255 candidates and returns the winner plus normalized probabilities for every candidate. A grading question is called score: it grades against an ordered rubric starting at 0 and returns a continuous weighted score plus per-level probabilities. Every answer carries a confidence score from 0 to 1, so your code can decide which cases to auto-approve, which to send to a fallback, and which to route to a human reviewer.

Google's blog gives a nicely down-to-earth example: a photo of a breakroom counter plus a text note, "Breakroom counter check before the 9 AM client meeting." The same request asks three questions at once: is there an uncleaned liquid spill on the counter, a yes/no question; what should happen next, a choice question with options to wipe it with a cloth, dispatch janitorial staff, or confirm the room is ready; and how severe is the mess, a score question on a scale from clean and ready to minor localized spill to major spill or safety hazard. The model answers: a 0.95 probability of a spill, a 98% probability that wiping with a cloth is the right next action, and a severity of 1.19 out of 2. The example is well chosen because it demonstrates three things at once: the input mixes image and text, three questions share one input, and everything that comes back is numbers rather than sentences. Code can feed 0.95 and 98% straight into an if statement; a paragraph like "there is some brown liquid on the counter, cleaning is advised" would need another parsing step first.

The calling convention is worth a mention too. The model runs on the Gemini API's v1beta endpoint; in Python you use google-genai 3.2 or later, a single client.decisions.create call with model set to gemini-decision-1, and the input field reuses the same Content block format as the Interactions API. Developers who have called Gemini before can wire this up by changing a few lines, with no new protocol to learn. Google also lists ecosystem integrations rolling out across OpenRouter, LangChain, Vercel AI SDK, LiteLLM, Pydantic AI, Pipecat, LiveKit, and OpenCode. Support for Gemini in Google Cloud (Vertex AI) is listed as coming soon, with no date — the one part that is explicitly not here yet.

Fast and cheap are two different things. This one claims both

Decision-making calls fear two things: being slow and being expensive. Slow, because a generative model has to emit its answer one token at a time, and by the time it has finished writing a sentence, the window for a routing decision has already closed; expensive, because every judgment costs a full generation even though all you wanted was a yes or a no. Gemini Decision 1's pitch is to bring both numbers down at once. Google's figures: median model compute of 50 to 100 milliseconds, 150 to 250 milliseconds end to end; latency stays nearly flat going from 1 question to 100 questions per request, for contexts up to 16K tokens. Pricing is $0.10 per million input tokens and $0 for output tokens — because it produces no output tokens at all.

Comparison chart: Gemini Decision 1 latency range and relative cost, figures from Google's official blog

The $0.10 price needs context. It is exactly the same input price as Meta's Muse Ember, Anthropic's Claude Haiku 5.5, and OpenAI's GPT-6 Luna — all $0.10 per million input tokens. But those three are generative models that also bill output at $0.50 per million tokens; Decision 1 has no output line on the bill at all. The billing model matters more: the shared input is billed once per request no matter how many questions are attached to it, and each question only adds its own instruction and criteria tokens. Google adds a pointed sentence: no output-token charges, no variable thinking-token bills, and no separate audio transcription and OCR costs. That sentence is written for people who have done the math before — the add-ons that make generative models look cheap and turn out expensive simply do not exist here.

Google also publishes a comparison: on its own benchmark suite, Gemini Decision 1 with the Decisions API costs nearly 5x less than Gemini 3.5 Flash-Lite with the Interactions API, while leading across the suite and posting the lowest calibration error. That sentence has to be read in two halves: the first half is a price comparison, the second half is a quality claim. The price comparison uses Google's own benchmark suite, and the "lowest calibration error" claim was measured on the same suite. Both conclusions are still awaiting independent verification. Keep that caveat in mind; the cold-water section below comes back to it in detail.

Still, the 150 to 250 millisecond latency figure is valuable without waiting for third-party verification. Every tool selection, every policy check, every context grading an agent performs is a judgment; a multi-step task can involve dozens of them. If each judgment has to wait for a generative model to finish writing a sentence, total task latency multiplies; if each judgment takes about two hundred milliseconds, the judgment step becomes a negligible share of total time. That is why Google calls the Decisions API a control plane rather than just another model: its place is not up front writing answers, but backstage directing traffic.

One input, one thousand questions: who is that limit for

A limit of 1,000 questions looks exaggerated at first glance. Who asks a thousand questions in a single request? The answer: anyone doing bulk review and bulk grading. Picture a content moderation pipeline: an article comes in and has to be checked at once for advertising, abuse, privacy leaks, misleading claims, suitability for minors, and whether a disclaimer is needed — dozens of yes/no questions already. Picture resume screening: a resume comes in and has to be rated on communication, project experience fit, technical depth, leadership potential, and culture fit — each a score question. Picture customer service quality checks: a call recording comes in and has to be rated on politeness, resolution rate, promises the agent should not have made, and whether procedure was followed — dozens more questions. These jobs used to need either hard-coded rule classifiers or a generative model writing out one judgment at a time; now a single request can ask them all and return a row of probabilities.

Multimodality is the other half of that limit. The input can pair a call recording with account metadata, a scanned PDF claim with damage photos, or a video with a text note. Google's examples include insurance claims and service recordings, and that is no accident: the scenarios that most need bulk judgment are usually the ones with the messiest inputs. Image and video inputs can also be tuned for resolution to control visual detail and token cost — a detail that matters in practice, because at bulk volumes token cost is billed by volume: drop the resolution a notch, and the cost drops a notch, and you can measure for yourself how much accuracy you lose.

The confidence score is the design's finishing touch, and also the easiest part to misuse. Every answer carries a confidence score from 0 to 1, and Google's advice is to route ambiguous cases to a fallback or a human reviewer. That sounds simple but needs a threshold policy: above 0.9 auto-approve, 0.7 to 0.9 get a second look, below 0.7 go to a human — and there is no universal answer for where the thresholds go; it depends on your own tolerance for error. Where a false approval is expensive, set the threshold high; where a false block is expensive, set it lower. Decision 1 returns probabilities, not verdicts; the verdict rules still have to be written by the user.

Four entrants in three months: the decision-model race is on

Google is not the first to build a decision model. This site already covered two entries in the same race in October: OpenAI's Decisions API, announced at DevDay on September 29, turning an agent's branch decision into a single 150-millisecond call; and TypeSafe's Jev, launched September 15, which raised an $870 million Series A at a $7.5 billion valuation three weeks later, led by a16z. Microsoft followed with Microsoft-Decision-1, built on Alibaba's Qwen. Google is the fourth entrant, arriving November 11. Three months, four major players plus a startup valued at $7.5 billion, all betting on the same idea: judgment is splitting off from generation to become a standalone primitive.

There are three reasons why that bet makes sense now. First, once agents started running, judgment calls got numerous before anything else did: in an agent task, the steps that need a long written answer are the minority, while the steps that need a choice are the majority — which tool, which branch, whether to continue, whether it is good enough, whether it can ship are all judgments. Second, using a generative model for a judgment is overkill: to get a yes or no you have to wait for it to write out its reasoning and conclusion, and neither the latency nor the cost fits. Third, probabilities are better control signals than prose: code can branch on a probability directly, trip a breaker on a confidence score, and audit a distribution; prose has to be parsed first, and a parsing error becomes a new failure point. Together, those three points turn decision models from "an interesting optimization" into "the missing piece of agent infrastructure."

The four players are not playing the same game, which is part of why this story is worth writing. OpenAI leads with the agent scenario — its Decisions API is one piece of its agent puzzle; TypeSafe leads with calibration and valuation — Jev's pitch is calibrated decisions rather than a large model; Microsoft leads with an open foundation — Decision-1 built on Qwen; Google leads with multimodality and scale — a thousand questions per request, text, images, audio, video, and PDFs all in one input. None of them is arguing "my model is smarter"; all of them are arguing "my judgments are cheaper, faster, and easier to drop into code." The competitive dimension has already shifted from intelligence to engineering metrics: latency, price, question limits, modality coverage, integration breadth. That is good news for users: when choosing, you can compare the numbers table instead of guessing who is smarter.

Google is already using it as its own control plane

The most revealing part of the announcement is Google's four internal uses. First, dynamic model routing in Gemini Notebook: the Decisions API works as a real-time router, instantly directing each incoming query to the best model tier and thinking level, serving everyday queries with up to 40% lower latency while reserving deep reasoning models for complex tasks. Second, the rapid canvas experiment in Stitch: the Decisions API generates playable wireframes of a product flow in seconds and applies voice or tap edits almost instantly, and when the flow feels right, one click hands the screens to the full Stitch experience for deeper polish. Third, emoji selection in CC from Google Labs: picking the right emoji reaction from a palette of more than 200 options in a fraction of a second, so reactions appear instantly without adding latency. Fourth, a safety layer for MCP tools in Search: the Decisions API detects adversarial behavior and content against adversarial evaluations with high efficacy within the latency envelope.

Those four examples cover four different positions: routing, generation, selection, and safety. Routing is something an agent does before every call, generation is real-time feedback in a design tool, selection is an instant reaction in a social product, and safety is the last checkpoint before a tool call. Google's point is clear: a decision primitive is not for one scenario only; it fits anywhere a "judge first, then act" step exists. For vibe coders, the four examples double as a selection guide: is there a step in your product that is "judge first, then act"? If yes, you can try it.

One caveat applies here too: all four internal uses are Google's own products, and the numbers are Google's own figures. Notebook's 40% latency reduction was measured on Google's own traffic shape; on your product, with a different intent distribution, the gain could differ. Stitch's "a product flow in seconds" sounds great, but the announcement does not go into generation quality or whether the output is directly usable. The value of internal use cases is proving "this can run in a real product," not proving "it will produce the same numbers in your product." Before adopting, run a small controlled comparison on your own scenario — that beats reading the announcement's numbers.

For vibe coders: start with these four small jobs

If your product already runs agents, the four most promising places to try the Decisions API are the ones Google names in the announcement: tool selection, policy checks, model routing, and context grading. Tool selection is something an agent does before every action: with a dozen tools at hand, which one fits? The old approach was to have a generative model write out its reasoning and then choose; now you can write "does this tool fit?" as a choice question and let Decision 1 return probabilities. Policy checks are the safety inspection before a tool call: will this call delete data, spend money, or message a user? Write them as yes/no questions and block anything below the threshold. Model routing is cost control: simple questions go to a cheap model, hard ones to a large model, and the routing itself runs on Decision 1 — the router costs less than the calls it routes. Context grading is quality control in RAG: of the ten retrieved passages, which are truly relevant and which are noise? Score each one and feed only the high scorers to the generative model.

Those four small jobs share one trait: they are high-frequency steps in an agent flow, running hundreds or thousands of times a day. Decision 1's pricing and latency are designed exactly for high-frequency small judgments: 150 to 250 milliseconds per judgment, $0.10 per million input tokens, no output charges. Ten thousand judgments a day, at a few thousand input tokens each, costs on the order of a few dollars; doing the same with a generative model would multiply both latency and the bill. What you save is not only money but the response speed of the whole task — faster judgments make every step of the agent faster.

The barrier to trying it is low. Google offers a no-cost tier, with an API key available in AI Studio for prototyping; Python, JavaScript, and REST guides are in the documentation; and three demo apps are ready to play with: Doorstep Parcels, Speed Sketch, and Find the Zoo Keeper. On the SDK side, google-genai 3.2 or later is all you need, and the common integrations — OpenRouter, LangChain, Vercel AI SDK, LiteLLM — are landing. Trying it costs an afternoon: take your most repetitive judgment type, wire it up, run a hundred calls, record latency, cost, and accuracy, and compare against your current setup. If the numbers are good, keep it; if not, roll back. There is no migration cost.

One more usage pattern deserves its own mention: bulk review. A single request can carry 1,000 questions, and that capacity fits offline batch processing best: a nightly batch of content moderation, resume screening, or service quality checks. Batch work is not sensitive to latency but is sensitive to cost and throughput, and Decision 1's "the input is billed once" model pays off most here: one input carrying dozens of questions spreads the cost of each question very thin. Real-time scenarios use it to save latency; batch scenarios use it to save money. Both work.

Cold water: three questions still unanswered

First, the benchmark numbers are all Google's own. The announcement's "leads across the suite, with the lowest calibration error" and "nearly 5x cheaper" both rest on Google's own benchmark suite, with no independent verification. More importantly, the suite itself is not fully disclosed: how the agent routing, reasoning, ranking, and multimodal understanding dimensions are weighted, what the test sets look like, or why Gemini 3.5 Flash-Lite was chosen as the comparison instead of a rival's model — none of that is in the announcement. Google's numbers deserve more trust than a small vendor's sales pitch, but more trust is still not independent verification. Until third parties publish head-to-head comparisons, read "leading" and "5x" as vendor claims, not conclusions.

Second, Vertex AI support has not arrived. The announcement says "coming soon" with no date. That means the only places to use the Decisions API today are the Gemini Developer API and AI Studio. Enterprise users who have already built their infrastructure on Vertex AI in Google Cloud cannot plug in yet and have to wait. How long the wait is, the announcement does not say. For individual developers and small teams this is not a problem; for teams already running production traffic on Vertex AI, it is a clear gate: prototype on the Developer API now, move to production when Vertex support lands.

Third, and easiest to overlook: no amount of calibration can rescue badly written decision criteria. The probabilities Decision 1 returns are computed against the criteria you wrote; if the criteria are vague, the probabilities are precisely computed for a vague question. The true/false descriptions for yes/no questions, the candidate definitions for choice questions, the scale markings for score questions — all of these are written by the user. Writing good criteria takes work: test against dozens of real cases, see how the model judges the borderline ones, and revise the criteria. The announcement does not mention that work, but it is the step that actually determines results. Treat the Decisions API as a "plug it in and it works" answer and you will be disappointed; treat it as "a cheap, fast engine for judgments, with criteria you still have to craft yourself" and your expectations will be right.

Drawing the line against the two decision-model stories already on this site

This is not the first decision-model story on this site, so the boundary needs stating upfront. In October we covered OpenAI's Decisions API — OpenAI turning an agent's branch decision into a single 150-millisecond call at DevDay — and TypeSafe's Jev — a startup outputting calibrated decisions from a non-LLM Transformer, valued at $7.5 billion three weeks after launch. Those two covered OpenAI's agent puzzle piece and a startup's calibration route respectively; this one covers Google's entry: multimodal input, a thousand questions per request, 150 to 250 milliseconds, $0.10 per million input tokens. Same race, different players and different plays.

Nor should Decision 1 be confused with a new generative model like Gemini 4 Carbon. This site covered Gemini 4 Carbon's general availability on November 10 — Google's strongest generative model, playing the "smarter" game; Decision 1 plays the "cheaper, faster, judgment-only" game. Both will show up in agent flows: Decision 1 judges which tool to call and which branch to take, and the generative model executes and writes the answer. Different jobs, no substitution.

One sentence to close: in three months the decision-model race went from one player to four, which says agent infrastructure is splitting into layers — generation for generation, judgment for judgment. Google's entry prices judgment at $0.10 per million input tokens and about two hundred milliseconds. For anyone whose agents make hundreds or thousands of small judgments a day, that is a real cost cut and a real speedup; for anyone who has not got agents running yet, build up the volume of judgment calls first, then decide whether to switch engines. Take your most repetitive judgment type, run it a hundred times, record latency, cost, and accuracy — the numbers will give you the answer.

Views 8Comments 0

Comments (0)

ME
0/1000
Loading comments...

Sources

Browse projectsPublish your project

Related articles

A developer with glasses types on a laptop at a wooden desk, an external monitor to the left showing C code on a dark background, a small plant on the desk
News
Microsoft's Coding Model Stops Playing Second Fiddle: MAI Code 2 Scores 96% of Opus 5.5 for 5% of the Cost — Read the Three Caveats First

On 17 November 2026, Microsoft launched MAI Code 2 and Code 2 Flash: the larger model has 77 billion active parameters and a one-million-token context, averaging 63.2% across four benchmarks — close to GPT-6.1 Sol and Claude Opus 5.5 — at $0.309 per task. Read the three caveats first: promotional pricing, the lowest score of the three, and no long-horizon work.

Developer WorkflowProduct LaunchModel Updates
Against a black background, a conductor seen from behind raises a baton, with swirling trails of light circling beneath him like an orchestra being conducted
News
One API for 45 Models, and It Switches Providers When One Fails: Perplexity's Orchestrator Wants to Be the Switchboard

On 17 November 2026, Perplexity launched the Orchestrator API: one interface reaching OpenAI, Anthropic, Google, xAI and open-weight models such as GLM, Kimi and DeepSeek, billed at the answering model's published rate with no platform fee. When one provider fails, the same model retries on another deployment, and preview routing assigns requests to models by task.

Developer WorkflowProduct LaunchModel Updates