NEW · TOOL OF THE DAY · 13 NOVEMBER 2026
Gemini Decisions API: When AI Should Choose, Not Chat
Imagine a support team at a small travel company. A customer sends a photograph of a damaged suitcase, a voice note from the airport, and a short booking reference. The team does not need a lyrical paragraph from an AI. It needs three dependable first-pass answers: Is the bag visibly damaged? Should this go to baggage services or a human supervisor? How urgent is the case? The human still decides what to do, but sorting the inbox takes time.
That is the kind of narrow job Google says its new Gemini Decisions API is designed to handle. The imagined travel desk is an illustration, not a real company or a test we conducted. The useful question is not whether a model can sound clever. It is whether it can make a bounded choice quickly, return a format software can use, and know when to hand uncertainty to a person.
What is Gemini Decisions API?
Google announced the Gemini Decisions API on 11 November 2026. It is a developer API powered by Gemini Decision 1, available through the Gemini API and Google AI Studio. It is not a consumer chat app with a new button. A developer sends an input and a set of questions; the API scores answers from a defined set instead of composing a long response token by token.
The shared input can contain text, images, audio, video, or PDFs. Google says it can evaluate up to 1,000 independent questions against one shared input, with a context of up to 256,000 tokens. Each question asks for a yes/no judgment, a choice from a list, or a score against an ordered rubric. The response includes probabilities and a confidence value. Google describes end-to-end latency of 150–250 milliseconds and a paid input price of $0.10 per million tokens, with no output-token charge. Those speed, performance and price statements are Google’s published claims, not results independently measured by AIstratica.
For a non-technical reader, picture a form with a fixed menu of answers. A normal chatbot is asked to write the answer; this API is asked to select the best-fitting option from the menu. That makes it potentially useful inside an application—for routing, triage, moderation checks, ranking or grading—not a replacement for a general assistant.
What it can do in practice
1. Yes-or-no checks
The noul question type estimates whether a stated condition holds. A retailer could ask whether an uploaded product photo shows a broken seal; a school platform might flag whether a submission appears to contain a citation. These are screening signals, not final findings. A false negative can matter more than a slow queue, so people should define what happens when confidence is low.
2. Choose among options
The choice type selects from two to 255 candidates and returns normalized probabilities for the options. A help desk could route a message to “billing,” “technical support,” or “human review.” The team must write useful options and criteria. If “other” or “unclear” is missing, the system may confidently choose the least-wrong answer from a bad menu.
3. Score against a rubric
The score type evaluates an input against ordered levels. A teacher could use it to sort short practice answers into “needs another example,” “mostly correct,” and “ready to move on.” It should not quietly become an unreviewed gradebook. The rubric can encode a poor standard just as efficiently as a good one.
4. Ask several questions over one input
Instead of making separate calls, a team can submit multiple questions about the same shared material. For a support message, those might be “Is there a safety issue?”, “Which team should receive it?” and “How urgent is it?” Google says the shared input is billed once per request while each question adds its own instructions and criteria tokens. The practical benefit is fewer repeated uploads and a compact workflow; it does not mean every question is free of token cost.
5. Combine formats
The API accepts mixed modalities, so an application could evaluate a photo alongside a note, or a recording alongside account details. This could reduce the awkward handoff between transcription, image recognition and text classification. Google says the API processes these formats in a single forward pass. That is a product description, not proof it will read every blurry label or noisy voice note correctly.
Try Gemini Decisions in 20 Minutes
This is a small developer exercise, not a no-code tutorial. You will need a Google AI Studio API key, a recent Python installation and the google-genai package. Use a fictional, non-sensitive support message. Do not paste customer records, health details or confidential documents into a free-tier prototype: Google’s current API pricing page says free-tier content may be used to improve its products, while paid-tier content is not used for that purpose. Review the current terms before using real data.
- In Google AI Studio, create an API key and follow Google’s current Gemini API setup instructions. Keep the key out of code you share publicly.
- Install Google’s SDK in a terminal with
python -m pip install google-genaiand configure the API key using the method in Google’s official guide. - Create a short fictional message, such as: “My suitcase wheel broke during the flight. I have a connection in 40 minutes. Booking: DEMO-123.”
- Send one multiple-choice question and one urgency score. Review both the selected answer and the confidence values; then change the wording of the criteria and see whether the result changes.
Google’s launch example uses this Python call pattern. Replace the text and criteria with your own test, and check the current API reference before adapting it for a real application:
from google import genai
client = genai.Client(http_options={"api_version": "v1beta"})
result = client.decisions.create(
model="gemini-decision-1",
input=[{
"type": "text",
"text": "DEMO ONLY: A traveller says a suitcase wheel broke before a connection.",
}],
questions={
"team": {
"type": "choice",
"instructions": "Which team should review this message first?",
"criteria": {
"baggage_support": "Damaged or delayed luggage.",
"booking_support": "Ticket, itinerary, or reservation change.",
"human_review": "Urgent safety issue or unclear case.",
},
},
"urgency": {
"type": "score",
"instructions": "Rate how soon a person should review the case.",
"criteria": [
"Routine; can wait until the next working day.",
"Time-sensitive; review within a few hours.",
"Urgent; a person should review immediately.",
],
},
},
)
print(result)The twenty-minute goal is to produce and inspect a first result, not to build a reliable customer-service system. A real deployment needs test cases, privacy review, access controls, logging, escalation rules and a human appeal route.
Pricing and plans
Google’s launch post lists the Decisions API at $0.10 per one million input tokens and $0 per output tokens, with an API no-cost tier for prototyping. It does not present monthly subscriptions for this endpoint. Usage is metered; check AI Studio and the official pricing page immediately before production use for current availability, quotas and account terms.
| Access | Published price | What to know |
|---|---|---|
| API no-cost tier | No charge within Google’s current limits | For prototyping; quotas can apply. Google says free-tier content may be used to improve products. |
| Paid API | $0.10 / 1M input tokens; $0 output tokens | Usage-based, not a monthly seat plan. The shared input is billed once per request; question instructions and criteria add input tokens. |
Pricing checked: 13 November 2026. Official pages: Google’s launch announcement and Gemini API pricing. No commercial-use or service-level guarantee should be inferred from the headline price; consult the current API terms and regional availability.
How it compares
| Option | Distinctive strength | Best suited to | Trade-off |
|---|---|---|---|
| Gemini Decisions API | Purpose-built bounded choices across mixed media; returns scores without generated prose | Developers who need fast routing, triage or rubric scoring | New endpoint; requires integration and careful evaluation. Google’s latency and benchmark comparisons are vendor-reported. |
| Gemini API with a generative model | Can explain, draft and handle open-ended instructions | Teams needing flexible language generation alongside classification | Generated text can add latency and requires parsing or structured output controls. |
| A conventional rules engine or classifier | Predictable rules and transparent, narrow behavior | Stable categories with clear definitions and sufficient labeled examples | Less flexible with messy multimodal inputs; rules need maintenance and classifiers need training data. |
These are different tools for different jobs, not a leaderboard. If a handful of explicit rules solves the problem, a language model may be unnecessary. If staff need an explanation, a decision-only endpoint may leave them asking “why?”
What doesn’t work well—or remains unknown
- It is not a chat assistant. The API returns structured decisions, not a polished explanation or a draft reply. Another system may be needed to explain the outcome.
- Confidence is not certainty. A score is a model estimate. It does not guarantee calibration on your data, and a high score does not make a consequential decision fair or correct.
- The menu shapes the answer. Missing choices, vague criteria or culturally narrow assumptions can force a bad selection. Include an “uncertain” or human-review route where appropriate.
- It is new. At publication, the announcement is only two days old. Independent long-term reliability evidence, operational edge cases and real-world failure rates are not yet established.
- Google’s headline performance claims need context. The 150–250 ms latency and benchmark results come from Google. Actual response time depends on network, input size, location, service load and implementation.
- Privacy differs by tier. Google’s pricing page distinguishes free and paid data use. Teams must check terms, retention, regional rules and sensitive-data requirements before sending real inputs.
- API work is work. A non-developer can inspect AI Studio, but building this into a dependable product requires code, evaluation, monitoring and fallback design.
- Low unit price can still add up. Repeated inputs, long files, high request volume and poorly written criteria affect total use. Measure costs with representative traffic before launch.
AIstratica’s verdict
Best for: Developers who need a fast first-pass decision from a fixed set of options, especially when one input contains more than text.
Worth trying? Yes, if you can use an API and have a low-risk prototype. The no-cost tier is useful for exploring, subject to its limits and data terms.
Worth paying for? Potentially, when measured latency or repeated classification matters and your own evaluation confirms it works. The advertised token price is attractive, but total cost and error handling depend on the application.
Biggest strength: It makes “choose one of these, and tell me how sure you are” a first-class API task.
Biggest limitation: It produces a decision signal, not the reasoning, accountability or human judgment that may need to follow it.
This assessment is based on Google’s official launch and pricing documentation, not hands-on testing. We have not independently verified performance, calibration or the advertised benchmark comparisons.
A smaller answer can be the more useful one
The travel team in our opening scene does not need an AI to write a moving monologue about a broken suitcase. It needs a sensible first route, a clear uncertainty signal and a person ready to take over when the case is unusual. Gemini Decisions is built for that quieter corner of AI: the moment software must choose before anyone asks it to chat.
That can make work smoother. It can also make a wrong choice move faster. The value lies in the system around the model—the options, the checks and the human handoff—not in speed alone.