Gemini Decision 1: Google’s AI That Decides, Not Writes

Gemini Decision 1 is Google’s newest AI model, and it breaks the pattern every other Gemini model follows: it never writes a single word. Launched on 11 November 2026 alongside the Gemini Decisions API, Gemini Decision 1 answers up to 1,000 yes-or-no, multiple-choice and rubric questions about one shared input — text, an image, audio, a video or a PDF — in a single pass, returning a probability for every answer in 150 to 250 milliseconds. It costs $0.10 per million input tokens, and output is free, because there is no output text at all.

That sounds like a small idea. It is not. Most of the work inside a modern AI product is not writing paragraphs. It is the hundreds of small judgements that surround the writing: which tool should the agent call next, does this message break a policy, is this answer good enough to send, which model should handle this request, does this invoice match the contract. Until now, developers answered those questions by asking a chat model to generate text and then parsing the reply — slow, expensive and unreliable. Gemini Decision 1 turns each of those judgements into a number your code can branch on directly, and it does it roughly five times cheaper than the generative route Google compared it against.

This guide explains what Gemini Decision 1 actually does, how the Decisions API works, what it costs in real money, where Google’s own benchmark claims hold up and where the independent scoreboard disagrees, and — most importantly — what you can build with it today and what you should not trust it with yet.

Table of Contents

What Is Gemini Decision 1?

Gemini Decision 1 is a purpose-built decision model from Google DeepMind, announced on 11 November 2026 in a blog post by Min Choi and Felix Yu. It is not a chatbot, not a reasoning model and not a smaller Gemini with a different name. It belongs to a new category of model that the industry started calling “decision models” in the second half of 2026: models that take a bounded set of candidate answers and score them, instead of generating free-form text token by token.

The distinction matters more than it first appears. A normal language model answers a question by predicting one word at a time until it decides to stop. That is flexible, but it is also slow, it costs output tokens, and the answer arrives as prose that your code then has to interpret — usually with a fragile regular expression or a second model call to extract a clean yes or no. Gemini Decision 1 skips the prose entirely. You give it one shared input and a list of closed questions, and it returns a probability for every option in a single forward pass. Your code receives numbers, not sentences, and numbers are something software can act on without a parser in between.

Google positions the model as infrastructure for agents rather than as a product for end users. The launch post names four jobs it is built for: tool selection (which tool should an agent call), policy checks (does this input or output break a rule), model routing (which model should handle this request) and context grading (is this retrieved document actually relevant). Those four jobs are the hidden plumbing of every agent system, and they are exactly the jobs where a chat model’s text output is most awkward. A router does not need a paragraph explaining why a request belongs in the billing queue. It needs a number, fast.

There is already a real deployment inside Google to point at. Google says its Gemini Notebook product already uses Gemini Decision 1 as a real-time router, and that the switch cut latency on everyday queries by up to 40%. That is a meaningful detail for two reasons. First, it means the model was tested in a production product before the public announcement, not merely on a benchmark. Second, routing is the use case where the model’s design advantage is largest: a router runs on every single request, so a 150-millisecond, near-free judgement compounds into a visible speed improvement across the whole product.

Availability is narrow at launch, and that is part of the honest picture. Gemini Decision 1 runs on the Gemini Developer API only, at API version v1beta, and you reach it through Google AI Studio with a Gemini API key. There is no Vertex AI listing yet — Google says Google Cloud support is “coming soon”, with no date and an early-access form for teams that want it. There are no weights to download, no self-hosted option and no chat interface. If your organisation buys AI exclusively through Google Cloud, the model is currently not on the shelf you shop from, and that is a real constraint for enterprise buyers, even though integrations with OpenRouter, LangChain, Vercel and LiteLLM were announced as rolling out at launch.

How Gemini Decision 1 Works

The core idea behind Gemini Decision 1 is simple to state and unusual in practice: one input, many questions, one pass, all numbers. You send a single multimodal input — text, an image, audio, a video or a PDF, up to 262,144 tokens in total — together with up to 1,000 independent questions about that input. The model scores every candidate answer for every question in one forward pass and returns calibrated probabilities. The input is billed once per request, no matter how many questions ride on it, and the model returns zero output tokens, which is why output is free.

That shared-input design is where the economics come from. The old way of answering twenty checks about one document was to send the document twenty times, once per check, and pay for it twenty times. With Gemini Decision 1, you send the document once and attach twenty questions. Google’s own worked example makes the difference concrete: a 4,000-token record with twenty checks that add 50 tokens each costs about $0.50 per 1,000 records through the Decisions API, against about $8.10 per 1,000 records if twenty separate generative calls each resend the record. The saving is not a small optimisation. It is a sixteen-fold difference, and it is the reason this model exists.

The Three Question Types in Gemini Decision 1

Every question you ask Gemini Decision 1 must be one of three types, and the type decides what shape of answer comes back.

Yes/no questions ask whether a condition holds — for example, “does this photo show a spill on the floor?” The model returns one probability, clamped between 0.01 and 0.99, so it never reports absolute certainty. A result of 0.95 means the model is confident the condition holds; 0.08 means it is confident it does not. Your code picks a threshold — say, 0.8 — and acts above it.

Choice questions ask the model to pick one option from a list of 2 to 255 named options, and the model returns a probability for each option. This is the tool-selection shape: “which of these five tools should handle this request?” The probabilities always spread across the options you supplied, and the highest one is the model’s pick. The spread itself is useful information — a 0.9 top choice is a confident routing decision, while a 0.42 top choice among five options is a signal to escalate to a human or a bigger model.

Score questions rate the input on an ordered rubric you define, with 2 to 255 levels, and the model returns a probability-weighted expected level. This is the grading shape: “rate this draft reply for politeness on a scale of 1 to 5”, or “how complete is this invoice against the contract, from 0 to 10”. Instead of asking a chat model to write a review and then extracting a number from it, you get the number directly, with a distribution that shows how sure the model is.

One Shared Input, Billed Once — and the Catch

The shared input can be genuinely multimodal. The same request can carry a photograph, a recorded call, a video clip or a PDF alongside text, and the 262,144-token budget covers the input plus the instructions and choices for all questions combined. That total budget is the detail developers most often get wrong. It is not 262,144 tokens for the input plus unlimited room for questions. The questions eat into the same budget, so a 250,000-token contract leaves only about 12,000 tokens for the questions and their instructions, and a request that exceeds the total simply fails. For most real workloads — a support ticket, a photo, a ten-page document — the budget is generous. For very long documents with hundreds of questions attached, you need to count tokens before you send, not after the request fails.

There is one more structural fact that shapes everything you build on this model. Gemini Decision 1 cannot explain its answers. It returns scores, not prose, and there is no reasoning trace to inspect. If it scores a loan application as high risk with 0.91 probability, it will not tell you which clause of the application drove that number. That is not a bug in this release; it is the design. The model trades explainability for speed and cost, and any system that needs an audit trail for individual decisions has to build that audit trail itself — by logging the input, the question set and the returned probabilities, and by keeping a human or a generative model in the loop for the cases that matter.

Gemini Decision 1 developer coding an AI agent that uses decision models for tool selection and routing

Gemini Decision 1 Pricing: What 1,000 Questions Actually Cost

Gemini Decision 1 pricing is deliberately simple: $0.10 per million input tokens, and $0 for output, because the model never generates output tokens. There is one paid rate for every modality — text, image, video, audio and PDF all cost the same per token — and the shared input is billed once per request while each question adds only its own instruction and criteria tokens.

To put that rate in context, it helps to compare it with the generative models developers were using for the same jobs before this launch. Google’s own comparison says Gemini Decision 1 is about five times cheaper than Gemini 3.5 Flash-Lite used through the Interactions API across its shared benchmark suite: $0.88 of total benchmark cost with Decision 1, against $4.14 with Flash-Lite. The comparison is Google’s own, so treat the exact multiple with the usual caution, but the direction is not in doubt — a model that returns zero output tokens will always be cheaper per judgement than a model that has to generate a paragraph to deliver the same verdict.

The honest price comparison, though, is not against Google’s own models. It is against the other decision models on the market, and there the picture is more mixed. TypeSafe’s Jev 1.14, the model Google’s own table shows beating Gemini Decision 1 on two of nine tests, is priced at $0.042 per million input tokens — less than half of Google’s rate. Drex Max v1.1 lists at $0.03 per million input tokens as a launch price, against a $0.06 list rate. On the independent Artificial Analysis Decision Index, which estimates what a million decision tasks actually cost at each model’s listed rate, Gemini Decision 1 comes out at $345 per million tasks — the most expensive model in the top half of the board — against $156 for Jev, $143 for Microsoft-Decision-1 and $103 for Drex Max. The reason is not only the per-token rate: Gemini Decision 1 reads more tokens to reach an answer than its rivals, so the per-task cost gap is wider than the per-token gap.

That does not make the model expensive in absolute terms. A million decision tasks for $345 is $0.000345 per task — a third of a thousandth of a dollar. At the volumes where this model makes sense, the per-task cost is rarely the deciding factor. What matters is the total bill at your volume, and the shared-input design is what keeps that bill small. If you are checking forty policy rules against every support message, one Decisions API call replaces forty generative calls. The saving from batching the questions dwarfs the difference between $0.10 and $0.042 per million tokens. If you are asking one question per request, though, the batching advantage disappears, and Jev or Drex Max will simply be cheaper for the same judgement. The pricing lesson is practical, not ideological: Gemini Decision 1 is cheapest when you use it the way it was designed — many questions, one shared input, one call.

There is also a free tier, and it is generous enough for real prototyping. In Google AI Studio, the no-cost tier for gemini-decision-1 allows 200 requests per minute, 50,000 input tokens per minute and 10,000 requests per day. Paid tiers raise those limits — Tier 1 allows 1,500 requests per minute and 50,000 per day, and Tier 2 removes the daily cap — but the free tier alone is enough to build and test a routing layer before spending anything. One condition deserves attention: Google lists the free tier as data that may be used to improve its products, which rules it out for anything sensitive. Prototype with synthetic or public data on the free tier, and move to a paid tier before you send real customer records through it.

Gemini Decision 1 pricing and data center infrastructure behind Google's decision model API

Speed and Latency: 150–250 Milliseconds, Flat

Speed is the second half of the Gemini Decision 1 value proposition, and it is the half that matters most for the routing use case. Google reports end-to-end latency of 150 to 250 milliseconds, with median model compute of 50 to 100 milliseconds, and — critically — latency that stays nearly flat as a request grows from 1 question to 100 questions, at contexts up to 16,000 tokens. A router that takes 200 milliseconds to decide is a router you can put in front of every request without users noticing. A router that takes two seconds is a router you can only use selectively.

The independent measurements are close to Google’s numbers but not identical. The Artificial Analysis Decision Index records a weighted average of 211 milliseconds per task for Gemini Decision 1, against 92 milliseconds for Jev 1.14 and 283 milliseconds for Drex Max. So on the independent board, Gemini Decision 1 is slower than the fastest rival but faster than the highest-scoring one. The 211-millisecond figure is a weighted average across six different evaluations, not a single clean measurement, so the right reading is that the model is fast in absolute terms — a fifth of a second per judgement — and mid-pack among decision models specifically.

The flat-latency claim is the one with the biggest practical consequence, and it is worth understanding why it is true. A generative model answers one question at a time, generating tokens sequentially, so ten questions cost roughly ten times the time of one. Gemini Decision 1 scores all questions in a single forward pass, so the tenth question and the hundredth question ride along almost for free. The limit is the 16,000-token context Google quotes for the flat-latency behaviour; beyond that, longer inputs will cost more time, as they do for every model. But for the workloads this model targets — a message, a photo, a short document, a few dozen checks — the latency profile is effectively constant, and that constancy is what lets you design systems that ask many questions without worrying that each additional question buys you more delay.

There is a useful comparison inside Google’s own product line. The company says Gemini Notebook’s switch to Gemini Decision 1 as a real-time router cut latency on everyday queries by up to 40%. Routing used to mean a generative call that had to produce an answer before the real work could begin. Replacing that call with a 200-millisecond scoring pass removes a visible chunk of the wait on every query. For a consumer product, 40% is the difference between a feature that feels instant and one that feels sluggish. For a developer building an agent, it is the difference between a router you can afford to run and one you have to cache around.

Benchmarks: Google’s Claims vs the Independent Scoreboard

Every new model launch comes with a benchmark table, and Gemini Decision 1 is no exception — except that Google’s launch does not include a full independent table, and the table it does publish deserves a careful read. The launch post says Gemini Decision 1 “leads across the suite, with the lowest calibration error”, and the numbers behind that sentence are real: a Top-1 expected calibration error of 0.0250, against 0.0494 for TypeSafe’s Jev 1.14, 0.0721 for OpenAI’s GPT-6 Luna and 0.2104 for Google’s own Gemini 3.5 Flash-Lite. Calibration error measures whether a model’s confidence matches its accuracy — a model that says 90% and is right 90% of the time is well calibrated, and a model that says 90% and is right 60% of the time is dangerous, because your code will trust it. On this measure, Gemini Decision 1 is roughly twice as well calibrated as its nearest rival, and that is a genuine strength, because the whole point of a decision model is that your code acts on its probabilities without a human reading them first.

The accuracy side of Google’s table is more mixed than the headline suggests. The same table shows Gemini Decision 1 losing two of its nine rows to TypeSafe’s Jev 1.14, and costing more than Jev on the shared tests — $0.88 against $0.68. Google also reports that the model scored 92.2% on JevBench, ahead of GPT-6 Luna at 90.9%. These are Google’s own numbers, on Google’s own suite, and no independent party has reproduced them. That does not make them false, but it does mean they should be reported as what they are: first-party claims, not verified results.

The Independent View: Artificial Analysis Decision Index v2.1

The independent check comes from the Artificial Analysis Decision Index v2.1, a board that ranks decision models across six evaluations — including document review, tool calling, knowledge and reasoning — scoring each one as accuracy minus the Brier penalty for the confidence attached to the answer. On that board, Gemini Decision 1 scores 65.98, or 66 rounded, and sits ninth of 18 decision models at launch — just above the field median of 64. That is a respectable score and a misleading headline, because the composite hides a split personality.

On the knowledge and reasoning components, Gemini Decision 1 is first in the field outright. On the AA-Omniscience-Decision test, which carries 15% of the composite, it scores 66.3 — first of eighteen — with a 49.6% non-hallucination rate that drives the result, and it answers 13.2% of Humanity’s Last Exam questions correctly, the highest raw accuracy of any decision model on that test. On EvalSafe-O*NET, another 15% component, it scores 87.1, essentially tied with Microsoft-Decision-1 at 86.8. Where the model is asked to know things and reason about them, it is the best decision model on the board.

Where it is weakest is the component that carries the most weight. AA-Paperclip, worth 30% of the composite, tests document review: the model reads a document and must pass or fail it against a set of criteria, all or nothing. Gemini Decision 1 scores 56.8 there and passes only 33% of documents outright, against 63% for the field leader, Drex Max v1.1. That is a large gap on exactly the kind of task — long-document checking — that many buyers will want a decision model for. On When2Call, the 10% component that tests whether a model knows when to call a tool, Gemini Decision 1 scores 75.2% accuracy, behind Jev at 80.8% and Drex Max at 94.6%, and fourteenth of eighteen on the component ranking. So the honest summary of the independent board is a split verdict: best in the field at knowledge and reasoning, mid-table overall, and weak at the document-review task that carries the most weight.

One more honest note about the board itself. The ranking moves as models are added — a second read of the same page on 12 November already showed Gemini Decision 1 tenth of 19 rather than ninth of 18, with the same 65.98 score. The score is stable; the rank is not, because the field keeps growing. Quote the score, not the rank, if you are writing about this model a week from now.

Gemini Decision 1 vs Jev, Drex Max and Microsoft-Decision-1

The decision-model category is only a few months old, but it already has a real competitive field, and Gemini Decision 1 enters it as the first Google entry — the third vendor endpoint in the class since September 2026. Understanding where it sits against the other three named models on the Artificial Analysis board is the fastest way to decide whether it is the right one for your project.

TypeSafe Jev 1.14 is the closest rival and, on the numbers, the one to beat. It scores 66.23 on the Decision Index, a fraction ahead of Gemini Decision 1 at 65.98, and it does it in 92 milliseconds per task — less than half of Gemini’s 211 — at $0.042 per million input tokens and $156 per million tasks. It also wins two of the nine rows in Google’s own benchmark table. Jev is the efficiency pick: faster, cheaper, and marginally ahead on the composite. Its weakness is calibration — an expected calibration error of 0.0494, roughly double Gemini’s 0.0250 — which matters if your code acts on the probabilities without human review. If you are building a system where a wrong-but-confident answer is worse than a wrong-but-humble one, that calibration gap is worth more than the speed gap.

Drex Max v1.1 is the highest scorer on the independent board at 73, a full 6.6 points ahead of Gemini Decision 1, and it earns that lead where it counts most: 72.8 on the AA-Paperclip document-review component, passing 63% of documents outright, and 94.6% on When2Call tool-calling accuracy. It is also the cheapest of the three at $103 per million tasks, on a $0.03 per million token launch price against a $0.06 list rate. Its trade-offs are speed — 283 milliseconds per task, the slowest of the group — and a narrower context design: every question gets its own 131,072-token budget, where Gemini Decision 1 gives the whole request a shared 262,144 tokens. Drex is the pick for document-heavy work where accuracy matters more than latency. The launch price, though, is a temporary condition: read the $0.03 rate as a launch offer, not a permanent price, and budget against the $0.06 list rate for anything you expect to still be running in six months.

Microsoft-Decision-1 arrived in the same week as Google’s model and sits four points behind it on the board at 62.07, tenth of eighteen, at $143 per million tasks. The two hyperscaler models are genuinely close — Gemini Decision 1 leads on knowledge and reasoning, Microsoft-Decision-1 wins When2Call clearly at 88.0 against Gemini’s 80.5 on that component comparison, and both are weak on the AA-Paperclip document component. For most buyers the choice between them will come down to which cloud and which ecosystem you already live in, not to a six-point score gap. The more useful observation is that both hyperscalers shipped decision models within days of each other, which tells you the category itself has been accepted as real infrastructure rather than an experiment.

There is also the generative-model comparison that Google itself invites. Against GPT-6 Luna, OpenAI’s current flagship, Gemini Decision 1 scores 92.2% on JevBench versus Luna’s 90.9%, and its calibration error of 0.0250 is a third of Luna’s 0.0721. That is a striking result, but read it for what it is: a decision model beating a general-purpose model at a decision task is the expected outcome, not an upset. A hammer beats a Swiss Army knife at driving nails. The comparison that matters is against other hammers, and there Gemini Decision 1 is good, not dominant.

ModelDecision Index v2.1Time per taskCost per 1M tasksInput price
Drex Max v1.173283 ms$103$0.03 / 1M tokens*
TypeSafe Jev 1.1466.2392 ms$156$0.042 / 1M tokens
Gemini Decision 165.98211 ms$345$0.10 / 1M tokens
Microsoft-Decision-162.07—$143—

Scores, latency and per-task costs from the Artificial Analysis Decision Index v2.1, as reported in November 2026. *Drex Max $0.03 is a launch price against a $0.06 list rate. Rankings shift as new models are added to the board.

What You Can Build With Gemini Decision 1

The launch post lists four canonical jobs for Gemini Decision 1 — tool selection, policy checks, model routing and context grading — and those four cover most of what a decision model is for. But the interesting part is what those jobs look like as real products, because the model is only useful if you can see your own workflow in one of them.

Model routing is the flagship use case, and it is the one Google can already point to in production. Every request that arrives at an AI product has to go somewhere: a simple question to a cheap model, a hard question to a strong model, a billing question to a specialist. A generative router adds a full model call — and its latency and cost — in front of every request. Gemini Decision 1 replaces that call with a 200-millisecond scoring pass, and Gemini Notebook’s reported 40% latency reduction shows what that substitution is worth at scale. If you run an agent or a support product that routes thousands of requests a day, this is the use case to prototype first, because the saving is measurable on day one and the failure mode is graceful: a wrong route sends a request to a slightly wrong model, not to a wrong answer.

Tool selection is the same idea inside an agent. An agent with twenty tools needs to choose the right one for each step, and choosing badly is the most common reason agents fail. A choice question with twenty named options returns a probability for each tool, and the agent calls the highest. The probability spread is as valuable as the pick itself: when the top choice is 0.45 and the second is 0.41, the agent can ask a clarifying question or call a bigger model instead of guessing. That hesitation is something generative agents are notoriously bad at, and it is exactly what a calibrated probability makes possible.

Policy and safety checks are the quiet workhorse. A support agent that drafts replies needs a check before each reply goes out: does this message contain a refund promise the company cannot keep, does it disclose something it should not, does it match the tone policy. Forty such checks in one Decisions API call cost a fraction of a cent and return in a fifth of a second, which means they can run on every message rather than on a sample. The same shape works for content moderation, for checking that an agent’s planned action is allowed before it acts, and for grading whether a retrieved document is actually relevant before it is fed into a generation call — the context-grading job Google names, which saves generation cost by keeping irrelevant context out of expensive prompts.

Document and image review at volume is where the model is most often pitched and where the independent numbers urge the most caution. Checking a thousand invoices against a contract, or a thousand doorstep photos for parcel damage, or a thousand support tickets against forty policy rules — all of these are one shared input plus many questions, which is the model’s native shape. But the AA-Paperclip result says Gemini Decision 1 passes only 33% of documents outright on the all-or-nothing test, against 63% for Drex Max. That does not mean the model cannot do document review. It means that for document review specifically, you should prototype against Drex Max and Jev as well before committing, and you should keep a human or a generative model reviewing the low-confidence cases. The model’s own design gives you the tool for that: a probability below your threshold is a routing decision, not a failure.

There are also the smaller, delightful uses that show up once developers have the API in their hands. The launch coverage mentions emoji selection, visual search (“find the zookeeper” in a photo), Speed Sketch recognition, checking a breakroom photo for spills — a yes/no question returning “has_spill: 0.95” — and Stitch Rapid using the model for fast prototyping decisions. None of these is a business case on its own. Together they show what happens when a judgement costs a third of a thousandth of a dollar and takes a fifth of a second: developers start asking questions they would never have paid a generative model to answer.

Gemini Decision 1 business teams using AI decision models for policy checks and document review

How to Use the Gemini Decisions API

Getting started with Gemini Decision 1 takes minutes, and the shape of the code is the clearest explanation of the model itself. The endpoint is POST /v1beta/decisions on the Gemini Developer API, and the supported SDK path is google-genai version 3.2 or later, which exposes a client.decisions.create() call. You need a Gemini API key, which you create in Google AI Studio, and you enable the Gemini API service (generativelanguage.googleapis.com) — the Decisions API is a method of that service, not a separate product to enable.

A minimal request has three parts. First, the shared input: the text, image, audio, video or PDF the questions are about. Second, the model identifier, gemini-decision-1. Third, the questions themselves, each with a type — yes/no, choice or score — and, for choice and score questions, the options or rubric levels. The response returns one result per question: a probability for a yes/no question, a probability per option for a choice question, and a probability-weighted expected level plus the distribution for a score question. There is no streaming, no partial response and no text to parse.

A practical example makes the shape concrete. Imagine a support inbox where every incoming ticket needs three judgements before a human sees it: is this urgent, which of five queues should handle it, and how polite is the customer’s tone on a scale of one to five. One Decisions API call carries the ticket text as the shared input and all three questions together, and returns three numbers in about 200 milliseconds. The old approach — three generative calls, or one generative call whose prose reply you then parse — costs more, takes longer, and fails in a way that is harder to detect, because a malformed prose reply looks like a valid answer until something downstream breaks.

Three practical details from the documentation are worth knowing before you write the code. First, the model runs on v1beta only, not on the stable v1 API version, which means the interface can change and you should pin your SDK version. Second, the supported SDK needs Python 3.11 or later for the google-genai 3.2 release. Third, the free tier’s 200-requests-per-minute and 10,000-requests-per-day limits are generous for development but will bind quickly in production, so check your tier before you launch — Tier 1 raises the limits to 1,500 per minute and 50,000 per day, and Tier 2 removes the daily cap.

Integrations are arriving fast. LangChain shipped decision-model support in langchain-core 1.8.0 on the same day as the launch, with a model-router middleware in langchain 1.5.0, and Google says integrations are rolling out to OpenRouter, Vercel and LiteLLM. OpenRouter listed the model within hours of the announcement, though at launch it appeared only on its own detail route rather than in the main model listing. If you already build on LangChain or OpenRouter, the shortest path to trying Gemini Decision 1 is through the integration you already use, not through a raw API call.

Limitations You Should Know Before You Ship

The most important limitation of Gemini Decision 1 is also the most interesting, because it is a deliberate design choice rather than a missing feature: the model cannot abstain. A yes/no question always returns a probability clamped between 0.01 and 0.99, and a choice question always spreads probability across the options you supplied. There is no “I don’t know” output, no refusal, and no way to ask the model whether it is unsure in the way a human would mean it. The probability itself is the uncertainty signal — a 0.51 on a yes/no question is the model telling you it is guessing — but your code has to read that signal and act on it. Any system that treats the top answer as a decision without checking the confidence is building on a misunderstanding of what the model returns.

That design has a direct consequence for high-stakes decisions. A model that cannot decline will answer questions it should not answer, including questions where the input does not contain the information needed to decide. If you ask whether a photo shows a spill, and the photo is too dark to tell, the model will still return a number. The number will be close to the middle, and a threshold-based system will correctly route it for review — but only if you built the threshold. The launch coverage has already flagged this as the model’s sharpest edge, and the honest framing is that the lack of an abstention mechanism is a known gap in this first version, not a detail to discover in production.

The second group of limitations is about availability and platform maturity. Gemini Decision 1 is v1beta on the Gemini Developer API only. There is no Vertex AI listing yet, no context caching, no Batch API, and no Flex or Priority inference tiers. Repeated input across requests is billed in full every time, so a system that sends the same long document in many separate requests pays for it many times over — the batching saving only applies within a single request. Google says Vertex AI support is coming soon, but it has given no date, and teams that buy through Google Cloud should treat that as an open question rather than a promise.

There is also a data-handling condition on the free tier that enterprise users should not miss. Google lists free-tier usage as data that may be used to improve its products, which makes the free tier unsuitable for sensitive or customer data. That is a standard condition for Google’s free AI tiers, but it is easy to overlook when the free tier is generous enough to run a real pilot on. The safe pattern is to prototype on the free tier with synthetic data, then move to a paid tier before real records flow through the model.

Finally, the calibration claim — the model’s strongest selling point — is a property of the model on Google’s test suite, not a guarantee about your questions. Calibration is measured on specific distributions, and your questions, your documents and your thresholds will shift it. Before you let a probability drive an automated action — a refund, a blocked account, a dispatched technician — measure the calibration on your own data, with your own question wording, and set thresholds from your own measurements. A model that is well calibrated in general can still be badly calibrated on the one question your business depends on.

Gemini Decision 1 vs the OpenAI Decisions API

Google is not the first vendor to ship a decision endpoint. OpenAI launched its Decisions API in public beta on 6 October 2026, about five weeks before Google’s announcement, with the same basic idea: a typed-verdict API that returns a decision instead of generated text, priced at $0.10 per million input tokens. OpenAI claimed at the time that its endpoint was roughly ten times faster than its Responses API for the same judgements. The two launches together are what turned a niche idea into a category, and the comparison between them is the one enterprise buyers will actually make.

On price, the two are identical at the headline rate — $0.10 per million input tokens, no output charge — which means the choice between them will not be made on the price list. On capability, the public details diverge. Google’s model scores up to 1,000 questions per request against one shared multimodal input of up to 262,144 tokens, with three question types and a published calibration-error figure. OpenAI’s endpoint was launched with less public detail about its question limits and calibration, and independent comparison on the Artificial Analysis Decision Index puts OpenAI’s entry eighteenth of twenty-eight decision models at the time the board went live on launch morning — a low placement that says more about how new the board is than about the model itself, since the board’s field has been growing weekly.

The more useful comparison is architectural. Both vendors are betting that the future of agents is not one big model doing everything, but a system of specialised models: a decision model for the small judgements, a generative model for the writing, a reasoning model for the hard problems. Google’s version of that bet is explicit in its own product: Gemini Notebook already routes with Gemini Decision 1, and the company has said integrations are coming to the frameworks developers actually use. OpenAI’s version is the same bet from the other side of the market. For a developer choosing between them, the deciding factors will be mundane and practical: which API key you already have, which framework you already use, which vendor’s rate limits fit your volume, and which model’s calibration you have measured on your own questions. The headline rates are the same, so measure the thing that differs — your own workload — rather than comparing marketing pages.

There is one more entrant worth naming, because it frames the whole category. TypeSafe’s Jev, the model that beats Gemini Decision 1 on two of nine rows in Google’s own table, is a specialist vendor’s product, not a hyperscaler’s. Its existence is the reason the category is competitive already: the best decision model on the independent board for speed and cost is not made by Google, Microsoft or OpenAI. That competition is good news for buyers, because it means the hyperscalers cannot coast on brand. Google’s model has to earn its place on calibration and ecosystem, and it does — but only just, and only on the dimensions where it is actually strongest.

Who Should Use It — and Who Should Wait

Gemini Decision 1 is a strong fit right now for three groups of builders. The first is anyone running an agent or a support product that routes requests, because the routing use case is proven in production at Google, the latency saving is measurable, and a wrong route is a recoverable mistake. The second is teams that already check many rules against every message, document or image — moderation, policy, quality grading — because the shared-input design turns forty separate calls into one, and the saving is large enough to matter from the first week. The third is developers building on Google’s stack who want a decision layer that integrates with AI Studio, LangChain and OpenRouter without changing vendors.

It is a weaker fit, for now, for three other groups. If your organisation buys AI exclusively through Google Cloud and cannot use the Gemini Developer API, the model is not yet on your shelf — wait for the Vertex AI listing. If your core workload is long-document review where an all-or-nothing pass matters, the independent numbers say to prototype Drex Max and Jev alongside it before committing, because Gemini Decision 1 trails both there. And if your decisions need an explanation attached — a regulated decision, a credit decision, a medical triage decision — this model cannot give you one, and no threshold trick will manufacture an audit trail the model does not produce.

For everyone in between, the right move is a small, honest prototype. Pick one workflow with a clear ground truth — a hundred support tickets you have already labelled by hand, a set of photos you have already judged, a routing decision you can verify. Run the same questions through Gemini Decision 1 on the free tier, measure accuracy and calibration on your own data, and compare the bill against the generative approach you use today. The model is cheap enough that the prototype costs almost nothing, and the measurement takes an afternoon. That is the correct way to evaluate a decision model: not by reading its benchmark table, but by asking it your questions and checking its answers.

Frequently Asked Questions

What is Gemini Decision 1?

Gemini Decision 1 is Google’s decision model, launched on 11 November 2026 with the Gemini Decisions API. Instead of generating text, it scores up to 1,000 yes/no, multiple-choice or rubric questions against one shared multimodal input and returns a probability for every answer, in about 150 to 250 milliseconds.

How much does Gemini Decision 1 cost?

Gemini Decision 1 costs $0.10 per million input tokens, with no output charge, because the model returns zero output tokens. A free tier in Google AI Studio allows 200 requests per minute and 10,000 requests per day for prototyping. On the independent Artificial Analysis board, a million decision tasks cost about $345 at the model’s listed rate — more than Jev at $156 or Drex Max at $103 — because Gemini Decision 1 reads more tokens per task.

Is Gemini Decision 1 a chatbot?

No. Gemini Decision 1 cannot chat, cannot generate text and cannot explain its answers. It is a scoring model that returns probabilities for a closed set of questions you supply. If you need prose, you pair it with a generative Gemini model — the decision model makes the judgement, the generative model writes the message.

Can Gemini Decision 1 say “I don’t know”?

No, and this is the model’s most important limitation. It always returns a probability — yes/no answers are clamped between 0.01 and 0.99, and choice questions always spread probability across the options. A probability near the middle is the signal that the model is unsure, so your code must check confidence and route low-confidence cases to a human or a bigger model.

Where is Gemini Decision 1 available?

Gemini Decision 1 is available on the Gemini Developer API at version v1beta, through Google AI Studio, with a free tier for prototyping. It is not on Vertex AI yet — Google says Google Cloud support is coming soon. Integrations with OpenRouter, LangChain, Vercel and LiteLLM were announced as rolling out at launch.

How is Gemini Decision 1 different from OpenAI’s Decisions API?

Both are typed-verdict endpoints priced at $0.10 per million input tokens, but they differ in the details: Google’s model handles up to 1,000 questions per request against a shared 262,144-token multimodal input and publishes a calibration-error figure of 0.0250. OpenAI’s endpoint launched five weeks earlier, in public beta on 6 October 2026. The practical choice between them comes down to which ecosystem and rate limits fit your workload.

Is Gemini Decision 1 better than Jev or Drex Max?

It depends on the dimension. On the Artificial Analysis Decision Index v2.1, Gemini Decision 1 scores 65.98 — ninth of 18 at launch — behind Jev at 66.23 and Drex Max at 73. It leads the field on knowledge and reasoning and has the lowest calibration error of the group, but it trails on document review and tool-calling timing, and it costs more per task than either rival. For routing and knowledge-heavy judgements it is the strongest of the three; for document review, Drex Max is the better prototype.

The Bottom Line

Gemini Decision 1 is a small model with a large implication. It says, plainly, that the most common job in an AI product is not writing — it is deciding. Which tool, which queue, which model, does this break a rule, is this good enough. Google has built a model that does only that job, does it in a fifth of a second, and charges a tenth of a dollar per million tokens for the privilege. The shared-input design, where one document carries a thousand questions for the price of one read, is the kind of idea that looks obvious only after someone ships it.

The launch is honest about what the model is not. It cannot explain itself, it cannot decline to answer, it is not on Vertex AI yet, and on the independent scoreboard it is ninth of eighteen — first at knowledge and reasoning, weakest at the document review that carries the most weight. Those are not reasons to ignore it. They are reasons to use it for the jobs it is actually good at: routing, tool selection, policy checks and grading, where a calibrated probability in 200 milliseconds is worth more than a paragraph in two seconds.

Google’s week has been a busy one — the same days that brought Gemini Decision 1 also brought Gemini 4 Hydrogen to the front of the Gemini lineup, and the two launches belong together: one model for the hard thinking, one model for the fast deciding. The agent systems that win in 2027 will be the ones that use both, each for the job it was built for. If you are building an agent, a support product or any system that makes the same small judgement a thousand times a day, the free tier is open in AI Studio right now, and an afternoon of measuring it against your own data will tell you more than any benchmark table can.

For readers following the wider agent story, the same week also saw DeepMind’s agents find two cracks in retired 1024-bit RSA — a reminder that agent infrastructure is advancing on every front at once, from the models that decide to the models that reason. And for the open-weight side of the same story, Meta’s Muse Spark Open remains the reference point for what an agent model looks like when it ships as weights rather than an API. Gemini Decision 1 is the hosted, closed-weight opposite of that bet — and the market now gets to decide which shape wins.

Sources: Google’s Gemini Decisions API launch post (blog.google), the Artificial Analysis Decision Index v2.1 as reported by VentureBeat, and the OpenRouter model page for gemini-decision-1. Google’s benchmark figures are first-party claims and are labelled as such in this article; independent figures come from the Artificial Analysis board. Prices and limits were verified on 13 November 2026 and may change.

Leave a Comment

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