Google Launches Gemini Decisions API With Gemini Decision 1 at $0.10/M Tokens

Google just rolled out the Gemini Decisions API, a model that doesn’t write prose but spits out calibrated probabilities for up to a thousand questions in a single call. The price tag? Ten cents per million input tokens, with zero output‑token charges. On paper that sounds cheap, but for anyone running an independent AI stack it raises a whole set of practical questions about cost, latency, and lock‑in.

What the Gemini Decisions API actually does

Gemini Decision 1 is a multimodal, closed‑set decision engine. It can ingest text, images, video, audio, and PDFs in one pre‑fill pass, then returns a probability for each question you ask. The API is built around three question types: a yes/no “noul” that yields a probability between 0.01 and 0.99, a “choice” that can handle 2‑255 options with normalized probabilities, and a “score” that rates an input on 2‑255 rubric levels and returns a weighted score. Every answer also includes a confidence value from 0 to 1, which Google recommends you use to route low‑confidence cases to a fallback or human reviewer.

Crucially, the model never emits output tokens. Your code branches directly on the numbers returned, meaning you avoid the token‑count overhead that plagues conventional text‑generation APIs. The request structure is simple: a model ID, a shared input, and a map of questions. The shared input is billed once, while each question only adds its own instruction and criteria tokens.

Performance claims and real‑world latency

Google reports median compute time of 50‑100 ms per forward pass and an end‑to‑end latency of 150‑250 ms. Those numbers hold for inputs up to 16 K tokens and stay nearly flat from one to a hundred questions. In practice, the model can score up to 1 000 questions per call, with each question processed in parallel and without seeing the others. That parallelism is a stark contrast to the token‑by‑token decoding used by standard LLMs, where each token adds latency.

Google’s own internal use cases—Gemini Notebook routing queries with up to 40 % lower latency, and Stitch’s rapid canvas building wireframes in seconds—suggest the speed gains are not just theoretical. For a founder running a production agent pipeline, shaving a few hundred milliseconds off each decision point can translate into noticeable cost savings on compute and better user experience.

Benchmark results: how does Gemini Decision 1 stack up?

Google pitted Gemini Decision 1 against three rivals: TypeSafe Jev 1.14, OpenAI’s GPT‑6 Luna (via OpenAI Decisions), and Google’s own Gemini 3.5 Flash‑Lite. Across nine benchmarks, Gemini Decision 1 led on seven, most notably achieving 92.2 % on the JevBench public split—four points ahead of Jev 1.14 and three ahead of GPT‑6 Luna. Its calibration error (ECE) of 0.0250 was about half that of Jev 1.14’s 0.0494, a meaningful gap when you’re setting confidence thresholds for automation.

Where Gemini Decision 1 lagged was on Amazon ESCI (Macro‑F1 58.7 %) and the When2Call benchmark (79.9 % vs Jev 1.14’s 82.0 %). Those lower scores signal that the model isn’t a universal winner; its strength lies in calibrated decision‑making rather than raw classification accuracy. For workloads that need tight confidence bounds—like fraud routing or compliance checks—the calibration advantage outweighs the modest dip in raw F1 scores.

Pricing reality: cheap or costly?

The headline price of $0.10 per million input tokens sounds modest, but it’s still higher than TypeSafe Jev 1.14’s $0.042 per million. Google claims the Gemini Decisions API is “nearly 5× cheaper” than its Flash‑Lite sibling, citing a total price of $0.88 versus $4.14 for the shared suite of evaluations. That relative cheapness only matters if you’re already comparing against Flash‑Lite; against Jev 1.14 the Gemini API is more expensive.

Another cost nuance: there is no caching support yet. Every request bills the full shared input, even if you reuse the same context across calls. In a production setting where you might batch dozens of routing decisions against the same document, the lack of prompt caching can erode the per‑token savings. For independent hosting providers, that means you need to factor in the repeated context cost when estimating total spend.

Lock‑in and ecosystem implications

The Gemini Decisions API is only available via Google‑hosted endpoints (Gemini Developer API v1beta). There are no open weights, no self‑hosting option, and no on‑premise deployment path. That’s a classic hyperscaler move: you get a slick service, but you hand over control of data and inference to a single vendor. For a founder who has spent a decade building and maintaining production servers, that loss of sovereignty is a red flag.

On the integration side, Google is rolling out SDKs and connectors for popular stacks—OpenRouter, LangChain, Vercel AI SDK, LiteLLM, Pydantic AI, Pipecat, LiveKit, and OpenCode. While that eases adoption, it also deepens the dependency on Google’s ecosystem. If you ever need to switch to an on‑prem model or a cheaper open‑source alternative, you’ll have to rewrite the decision‑layer logic anyway because the API contract is tightly coupled to Google’s request format.

Practical takeaways for independent AI providers

If you’re building an agent that needs rapid branching—think tool selection, policy enforcement, or multi‑modal content moderation—the Gemini Decisions API offers a fast, calibrated alternative to generic LLM calls. Its parallel scoring of up to 1 000 questions per request can reduce round‑trip latency dramatically, and the multimodal pre‑fill means you don’t need separate OCR or transcription pipelines.

However, you must weigh the higher per‑token price against the calibration benefit, and account for the lack of prompt caching. For workloads that reuse large contexts, the cost can climb quickly. Also, the vendor lock‑in risk is non‑trivial; once you embed Google’s API deep into your stack, migrating away will be costly.

Bottom line: use Gemini Decision 1 where calibrated probabilities and sub‑250 ms latency are mission‑critical, but keep a fallback path—perhaps an open‑source decision model or a self‑hosted ensemble—so you’re not stranded on a single hyperscaler. Test with a no‑cost tier in Google AI Studio, measure real‑world token usage, and compare the total cost of ownership against alternatives before committing.

Action plan for founders and ops teams

1. **Prototype quickly**: Spin up the free tier in Google AI Studio, hook the python SDK (v3.2+), and run a few hundred routing queries against a representative document set. Capture actual input token counts and latency.

2. **Benchmark confidence thresholds**: Use the confidence values returned to set a cutoff (e.g., 0.85) and route lower‑confidence cases to a human or a fallback model. Measure how often you hit that threshold and the impact on overall accuracy.

3. **Calculate true cost**: Multiply the input token volume by $0.10 per million, add any ancillary compute costs, and compare against a Jev 1.14‑based pipeline at $0.042 per million. Factor in the absence of caching.

4. **Plan for exit**: Abstract the decision‑layer behind an internal interface so you can swap the Gemini API for an on‑prem model if pricing or policy shifts.

5. **Monitor latency**: Keep an eye on the 150‑250 ms end‑to‑end claim. In high‑throughput environments, even a few milliseconds can add up, so instrument real‑time latency and set alerts if it drifts.

By treating the Gemini Decisions API as a tool—not a turnkey solution—you can harness its speed and calibration while safeguarding against the classic hyperscaler trap.

— Allan Ali, Founder

This article was produced with AI-assisted research and editorial support. Reporting is based on the source material cited below. Sources: MarkTechPost; marktechpost.com; Global1.News (12 November 2026).

By Allan Ali, Global1.News