Google Launches Gemini Decisions API: Yes/No and Choice Answers at $0.10 per 1M Tokens

Short answer: Google has launched the Gemini Decisions API, a new endpoint that answers closed questions (yes/no, pick one option, or score against a rubric) instead of writing text. It runs on a new model, Gemini Decision 1, which scores every option in a single pass and returns probabilities plus a confidence score. Google quotes 150 to 250 ms end-to-end latency, $0.10 per million input tokens and zero output tokens billed, with a free tier in Google AI Studio for prototyping.

What did Google ship?

According to Google’s announcement, the Decisions API is available now through the Gemini Developer API (v1beta) in Google AI Studio, using the model ID gemini-decision-1. Support in Gemini on Google Cloud is listed as coming soon.

The core idea is simple. You send one shared input and a map of questions. The model does not generate an answer token by token. It reads the input once and scores your candidate answers, so your code gets something it can branch on directly instead of text it has to parse.

• Input: text, images, audio, video and PDFs, up to 262,144 tokens of shared context per request.
• Questions: 1 to 1,000 independent questions per request, all evaluated against the same input.
• Output: a typed answer per question with probabilities and a confidence score from 0 to 1.
• SDKs: Python and JavaScript google-genai SDK 3.2 or later, plus REST.

The launch landed on the Hacker News front page within hours, a day after another decision model story (Amazon swapping Claude Sonnet 4.6 for the open-source Strands Decider on ticket labeling) drew heavy discussion there.

What are the three question types?

The Decisions API documentation defines three types, and you can mix them in one call:

Questions cannot see each other. Google’s guidance is to ask narrow, single-purpose questions and combine the answers in ordinary code with if statements and weights, rather than packing logic into one big prompt.

Here is the minimal call from the docs:

from google import genai

client = genai.Client(http_options={"api_version": "v1beta"})

result = client.decisions.create(
    model="gemini-decision-1",
    input="The blue mug I ordered on Monday arrived cracked on Wednesday.",
    questions={
        "is_damaged": {"type": "noul", "instructions": "Did the item arrive damaged?"},
        "queue": {
            "type": "choice",
            "instructions": "Which support queue should handle this message?",
            "criteria": {
                "billing": "Payment, invoice, or refund questions.",
                "replacements": "Damaged, missing, or wrong items.",
                "general": "Product questions and account updates.",
            },
        },
    },
)

print(result.answers["is_damaged"].noul, result.answers["queue"].choice)

How much does it cost, and how fast is it?

Google prices Gemini Decision 1 at $0.10 per million input tokens and $0 for output. The shared input is billed once per request no matter how many questions you ask; each question only adds its own instruction and criteria tokens. There are no thinking-token charges and no separate fees for audio transcription or OCR.

On speed, Google says median model compute is 50 to 100 ms, or 150 to 250 ms end to end, for multimodal inputs and contexts up to 16K tokens, and that latency stays nearly flat from 1 to 100 questions per request. Google also claims the Decisions API is nearly 5x cheaper across its shared benchmark suite than running Gemini 3.5 Flash-Lite through the Interactions API, and that Decision 1 leads its comparison suite with the lowest calibration error. These are Google’s own benchmarks; we have not reproduced them.

How does it compare with a normal LLM call?

The multimodal input is the clearest difference from the open decision models builders have been trying. In the Hacker News thread, several commenters pointed to image, audio and video support as the reason to consider it over existing decision-model services, while others noted it is not the cheapest option in this category and that OpenAI and startups already offer similar decision endpoints.

What is Google already using it for?

Google lists four internal uses, which are a useful map of where this kind of model fits:

• Model routing in Gemini Notebook: it classifies each query and sends it to the right model tier and thinking level, which Google says cut latency on everyday queries by up to 40%.
• Stitch: a rapid canvas experiment uses it to build playable wireframes and apply voice or tap edits almost instantly.
• CC from Google Labs: it picks an emoji reaction from more than 200 options in a fraction of a second.
• Google Search: a safety layer for MCP tools that flags adversarial behavior and content within a tight latency budget.

What does it mean for builders?

Many production LLM calls are really classifiers in disguise: routing a request, checking a policy, picking a tool, grading retrieved context, tagging an upload. If your prompt ends with “answer with one of these labels,” you are paying for generation, parsing and retries you do not need. The Decisions API turns those calls into typed answers with a confidence score your code can use to auto-approve clear cases and send unclear ones to a fallback model or a human.

A practical way to try it without risk:

1. Find one closed-choice call in your app, such as intent routing or content moderation.
2. Run the Decisions API in shadow mode next to your current model on real traffic and log both answers.
3. Pick a confidence threshold where agreement is high, and route everything below it to your existing path.
4. Only switch over once the logged comparison holds up on your own data.

What are the limits?

• No reasoning or explanations. It returns probabilities, not justifications. Anything that needs a written answer or multi-step thinking still needs a generative model.
• Google API only, for now. It runs on the Gemini Developer API (v1beta). There is no self-hosted option, and Google Cloud support is listed as coming soon.
• Text-only questions. Media goes in the shared input; question instructions accept text only.
• Media input rules. YouTube URLs and direct gs:// Cloud Storage URIs are not supported. Use the Files API, a public or signed HTTPS URL, or inline data.
• Vendor benchmarks. The speed, cost and calibration claims come from Google. Test on your own data before trusting the confidence scores.

What to watch next

Google says integrations are rolling out across OpenRouter, LangChain, Vercel, LiteLLM, Pydantic AI, Pipecat, LiveKit and OpenCode. That matters more than the launch itself: once routing and guardrail libraries can call a decision endpoint natively, swapping a generative classifier for a decision model becomes a config change rather than a rewrite. The other thing to watch is pricing pressure, since Google, OpenAI and open-source projects are now all competing for the same “cheap, fast judgment call” slot in agent stacks.

Key takeaways

• The Gemini Decisions API answers yes/no, choice and rubric questions with probabilities and confidence instead of text.
• Gemini Decision 1 costs $0.10 per million input tokens with no output charges, and there is a free tier in AI Studio.
• Google quotes 150 to 250 ms end to end, up to 1,000 questions and 262,144 tokens of multimodal input per request.
• Best fit: routing, policy checks, tool selection and tagging. Poor fit: anything that needs an explanation.
• Shadow-test it against your current model on real traffic before switching.

Image credit: Google