What Google released
On 11 November 2026 Google added the gemini-decision-1 model and a new Decisions API to the Gemini Developer API, according to the Gemini API changelog. The model doesn't write any text. You send one shared input, which can be text, images, audio, video or a PDF, along with a map of questions. Each question comes back with a typed answer and a confidence score, as the Decisions API guide describes. The model always produces zero output tokens, so you pay for input only. The paid tier costs US$0.10 per million input tokens. The free tier charges nothing for input, but Google may use free-tier data to improve its products.
Google's launch post is by Min Choi and Felix Yu of Google DeepMind. It gives end-to-end latency of 150 to 250 milliseconds and says latency stays nearly flat from 1 to 100 questions per request, for contexts up to 16K tokens. The post also says Google already uses the API to route requests between models in Gemini Notebook. Google Search uses it as a safety layer that spots adversarial behaviour in MCP tools (MCP is the Model Context Protocol, a standard way to connect tools to models).
How the question types work
The guide defines three question types:
noul(yes/no): returns the probability of "yes", between 0.01 and 0.99. You can add optionaltrue_descriptionandfalse_descriptiontext to pin down what each answer means.choice: picks one option from a fixed list of 2 to 255. Itscriteriafield maps each option ID to a description. The response gives the chosen option, a probability for every option (adding up to 1) and a confidence score.score: rates the input against ordered levels, numbered from 0. Itscriteriafield is an array listing the levels from lowest to highest. The score is a probability-weighted average of the level numbers, so a result can land between two levels.
The API scores all questions in parallel, and no question can see another question's answer. The guide defines confidence as the estimated probability that the top answer is correct. For a yes/no question, confidence equals max(noul, 1 - noul). "Calibrated" means the probabilities match how often the model is actually right: across many answers given 0.8, about 80% should be correct. Google says the model has the lowest calibration error across the tests in its own benchmark suite. The Decoder points out that no independent party has checked those figures.
A first request
The API is on the v1beta version of the Gemini Developer API and needs SDK version 3.2 or later. The Python quickstart in the guide asks one yes/no question about a customer message:
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?",
},
},
)
answer = result.answers["is_damaged"]
print(f"P(yes)={answer.noul:.2f} confidence={answer.confidence:.2f}")The REST version sends the same JSON body to POST https://generativelanguage.googleapis.com/v1beta/decisions, with your key in the x-goog-api-key header. Each answer in the response sits under its question's key in an answers map. A usage object lists input tokens by type of media and shows zero output tokens.
Building a support triage step
The guide's longer example sends two text blocks in one request. The first block holds order data and the customer's tier, and the second holds the customer's message. The request asks three questions:
- whether the message describes a hardware defect (yes/no)
- which of four resolutions to take (choice)
- how likely the customer is to leave (a four-level score)
The application acts on the chosen resolution only if the defect probability is above 0.9 and the confidence in the chosen resolution is above 0.6. Every other case goes to a human. A help desk, a returns queue or a content moderation step can use the same setup.
The guide gives several rules that apply to this kind of build:
- Text blocks: the API joins adjacent text blocks with no separator, so add your own newlines.
- JSON input: pass JSON as text and refer to fields by their key path in your instructions.
- Numbers and dates: compare them in your own code and pass in the result.
- Inputs that fit no option: choice probabilities always add up to 1, even when no option fits. Add a catch-all option with a key such as
other, or ask a separate yes/no question about whether the input is in scope. - Question wording: the model never sees question keys, so put the whole question in
instructions. Ask positive questions and flip the answer in code if you need the negative. - Thresholds: set them from labelled examples of your own traffic, weighing the cost of false positives against false negatives.
Limits to plan around
The model page lists a 262,144-token input limit, which covers the shared input and every question together. A request can hold 1 to 1,000 questions. Inline base64 data can be up to 100 MB per request (50 MB for PDFs). File URIs can be up to 15 MB each, and the API rejects YouTube links and gs:// URIs. Question instructions must be text, and the API doesn't accept conversation history, tool-call blocks or thought blocks. For a multi-turn chat, you have to write the context out as text.
The guide also says the API doesn't support context caching, the Batch API, or Flex or Priority inference. If you ask about the same long document in several requests, you pay for the full input each time. For now the API runs only on the Gemini Developer API. Google's post says support in Google Cloud is coming soon. The rate limits page allows the free tier 200 requests per minute, 50,000 tokens per minute and 10,000 requests per day. Tier 1 allows 1,500 requests per minute and 1,000,000 tokens per minute. Google notes that it doesn't guarantee these limits.
Cost and how it compares
Each request bills the shared input once, however many questions it carries. Each question adds its own instruction and criteria tokens. VentureBeat worked through an example: a 4,000-token record with 20 checks costs about US$0.50 per 1,000 records if all 20 checks go in one request, and about US$8.10 if each check is a separate call.
Gemini Decision 1 has competitors. VentureBeat reports that OpenAI's Decisions API became generally available on 22 October. It runs only on GPT-6 Luna and takes up to 400 questions per request. Uncached input costs the same US$0.10 per million tokens, and cache reads cost US$0.01 per million, which could make OpenAI cheaper if you keep asking about the same long document. VentureBeat also reports that Artificial Analysis's Decision Index v2.1 put Gemini Decision 1 ninth of 18 models at launch, with a score of 65.98. Nace AI's Drex Max v1.1 led on 72.62, and Jev 1.14 scored 66.23. Gemini's results vary by task: on When2Call, a test of whether a model knows when to call a tool, Gemini scored 75.2% against Drex Max's 94.6%.
What this means for NZ builders
Prices are in US dollars, and for now the API runs only on the Gemini Developer API. Teams that keep their AI spending inside a Google Cloud agreement will have to wait for the promised Google Cloud release. Prototype on the free tier with synthetic or public data only, because Google may use free-tier data to improve its products. Anything that contains customers' personal information belongs on the paid tier, where Google says it doesn't use your data that way.
The guide warns that you should treat all input as untrusted, test with adversarial examples and keep human review for decisions with serious consequences. VentureBeat describes a prompt-injection test on a competing model: one field planted in the input dropped the model's probability of blocking from 0.76 to 0.48. Try a test like that against your own prompts before letting a decision call act without a person checking. A sensible first build is a step that sorts incoming tickets or documents and sends anything below your confidence threshold to a person. If you build one, you can share it with other members on the ASAI projects page.
Sources
- Decisions API guide (Google AI Studio)
- Gemini API changelog
- Gemini Decision model page
- Gemini API pricing: Gemini Decision
- Gemini API rate limits: Gemini Decision
- Gemini Decisions API: Fast, calibrated multimodal decisions (Google blog)
- Google's Gemini Decision 1 model scores up to 1,000 questions in one API call (VentureBeat)
- Google joins the decision-model wave with Gemini Decision 1 (The Decoder)
Build with people working on the same things
Join the Auckland Society for AI: NZ$599 a year with a ForgeBox and the members' projects area. Our Auckland meetups are open to everyone.