11-20 更新 实时
首页/ 模型选型/ 正文

推出 Gemini Decision 1:只挑答案不写答案的模型

模型选型 来源:KDnuggets 2026-11-19 01:00 0 阅读 机器翻译
推出 Gemini Decision 1:只挑答案不写答案的模型

Google 的最新模型只做一件事,而且做这件事时一个字都不写。Decision 1 在一次前向传播中读取文本、图像、视频、音频和 PDF,每次请求最多可输入 262,144 个 Token。

作者:Shittu Olumide,技术内容专家,2026 年 11 月 18 日,发表于 Artificial Intelligence 栏目

Google 的最新模型只做一件事,而且做这件事时一个字都不写。上周随全新 Gemini Decisions API 一同发布的 Gemini Decision 1,接收一段输入和一组封闭式问题,返回的不是文字而是概率:是或否、选项 A、B 或 C、某个评分标准下的分数。

这听起来不算什么,但事实并非如此。每一套智能体技术栈都依赖几十次这样的静默调用:哪一模型来处理这条查询、触发哪个工具、这条消息是否违反策略。大多数团队用一个完整的生成式模型加一个 JSON 解析器来应付它们,为那些最终被丢弃的输出 Token 付费。如今 Google 把这层能力单独拿出来卖,价格为每百万输入 Token 0.10 美元,输出不收费。

Gemini Decision 1 能做什么

Decision 1 在一次前向传播中读取文本、图像、视频、音频和 PDF,每次请求最多可输入 262,144 个 Token。针对这一次输入,你可以提出最多 1,000 个相互独立的问题,共分三类:

是/否(API 中为 noul)返回 0.01 到 0.99 之间的概率

Choice 从 2 到 255 个选项中挑选,并为每个选项返回一个概率

按照有序评分标准对等级进行评分,并返回加权分数以及每个等级的概率

每个答案都带有一个置信度值,因此你的代码可以把不确定的案例转交给回退方案或人工处理。

定价就是卖点。每百万输入 Token 收费 $0.10,无论你问多少个问题,共享输入都只计费一次,而输出不收费,因为根本没有输出。Google AI Studio 中的免费层级可覆盖原型开发。

能力表展示了这个模型不具备什么。文本生成、思考、函数调用、结构化输出、批处理和缓存均列为不支持。它是一个评分引擎,而不是聊天机器人。

我们运行它时发生了什么?

我们安装了 Google 的 google-genai SDK,在 AI Studio 中创建了一个免费 API 密钥,并运行了三项测试:Google 的快速入门、发布文章中 Google 的图像示例,以及我们自己的一条含糊的客服消息。延迟是从我们的机器上计时的,因此包含网络往返时间。

快速入门示例针对一条客户消息提出两个问题:

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["queue"].choice, result.answers["queue"].confidence)

在图像测试中,输入变成一个包含图像 URL 和文本注释的列表。返回结果如下:

损坏:0.99。队列:更换(0.98)

“被重复收费,把手有缺口”

损坏:0.99。队列:更换 0.50,计费 0.48

溢出:0.95。操作:用布擦拭(0.98)。严重程度:2 分中的 1.19

中位数排除了每个测试的首次调用。准确率无可挑剔:Google 的两个示例都返回正确,图像结果也与 Google 自己的截图一致。每次调用计费的输出 Token 均为零。以美元计算,文本查询每次调用约花费 $0.000017,约 58,000 次调用花费 1 美元。图像查询每次约花费 $0.00013。

Google 已经在用它运行

Google 表示,其自家的四款产品使用了 Decisions API:

Gemini Notebook 将每个查询路由到相应的模型层级和思考级别,Google 称这能将日常查询的延迟最多降低 40%

Stitch 在其快速画布实验中使用该功能,来构建可操作的线框图,并应用语音或点按编辑

Google Labs 的 CC 从 200 多个选项中挑选一个 emoji 表情反应,而不会带来可感知的延迟

Google 搜索将其用作安全层,检查 Model Context Protocol 工具是否存在对抗性行为

1. 置信度分数才是真正的产品

我们那条含义模糊的消息才是真正关键的测试。它同时符合两个队列,模型也如实说明了这一点:50.2% 归入换货,48.4% 归入账单,置信度 0.50。它没有在一次五五开的选择上假装确定,而在同一次调用中,它仍以 0.99 的置信度将缺口手柄评为破损。

一个例子并不能证明校准能力,校准需要跨数千个案例来衡量。但这正是 Google 所推销的行为,而当我们刻意去寻找它时,它确实出现了。

2. 看置信度,而不只是看选择

陷阱就在这里。在那条正反难分的消息上,choice 字段仍然返回了备选项,却没有附带任何标记。只读取胜出结果的代码,会像处理明确情况那样自信地把它路由出去。

校准只有在你为置信度设定阈值、并把低于阈值的一切转往别处时才有意义。Google 的快速入门示例只打印胜出结果。你的生产代码不应止步于此。

3. 速度方面的说法在图像上并不成立

Google 宣称端到端为 150 至 250 毫秒。在首次调用之后,我们的文本调用落在 339 至 577 毫秒之间,这一差距用网络距离可以合理解释。我们的图像调用耗时 1.1 至 1.4 秒,中位数是其所宣称数字的 5 到 9 倍,尽管 Google 表示其数据在多模态输入下同样成立。

其中一部分原因可能是 Google 需要从 URL 抓取图像并处理 1,064 个图像 Token。从外部我们无法区分这些原因。还有两个细节:Google 的延迟数字覆盖的是最长 16K Token 的上下文,而非完整的 256K;而且在我们测试中,完全相同的调用波动超过 300 毫秒。在把它用于任何接近实时路径的场景之前,请用你自己的媒体素材做基准测试。

4. 基准测试是 Google 自家的

「便宜近 5 倍」这一数字,是把 Decision 1 与 Google 自家的 Gemini 3.5 Flash-Lite 相比,且是在 Google 选定的基准测试套件上。如果你已经在用 Gemini,这个数字有用。但对于 Decision 1 与你手上已有的小型微调分类器相比如何,它什么也没说明。

5. 看清细则条款

该模型页面主推对实时媒体流进行分类,但同一页面却把 Live API 列为不支持。而且该模型目前仅限 Gemini。它已上线 OpenRouter、LangChain、Vercel 的 AI SDK、LiteLLM 等平台,但 Google Cloud 支持仍标记为即将推出。

Decision 1 把一件窄领域的活儿干得很好。它便宜,在我们交给它的所有任务上都表现准确,而且当我们追问时它会承认不确定。现在就可以用它来做路由和策略检查。从第一天起就把你的代码接到置信度上,并在你自己的图像上测好耗时,再去向任何人承诺 200 ms。

Shittu Olumide 是一名软件工程师兼技术写作者,热衷于利用前沿技术打造引人入胜的叙事,注重细节,擅长把复杂概念讲得简单易懂。你也可以在 Twitter 上找到 Shittu。

译文由英文原文机器翻译,术语按行业惯例统一,可在文末展开原文核对。

查看英文原文(Introducing Gemini Decision 1: A Model That Picks Answers Instead of Writing Them)

Google's newest model has one job, and it never writes a word doing it. Decision 1 reads text, images, video, audio and PDFs in a single forward pass, up to 262,144 input tokens per request.

By Shittu Olumide, Technical Content Specialist on November 18, 2026 in Artificial Intelligence

Introducing Gemini Decision 1: A Model That Picks Answers Instead of Writing Them

Google's newest model has one job, and it never writes a word doing it. Gemini Decision 1, launched last week with the new Gemini Decisions API, takes an input and a list of closed questions and returns probabilities instead of prose: yes or no, option A, B or C, a score on a rubric.

That sounds small, but it isn't. Every agent stack runs on dozens of these quiet calls: which model gets this query, which tool fires, whether this message breaks a policy. Most teams handle them with a full generative model and a JSON parser, paying for output tokens they throw away. Google now sells that layer on its own, at \$0.10 per million input tokens and nothing for output.

What Gemini Decision 1 Does

Decision 1 reads text, images, video, audio and PDFs in a single forward pass, up to 262,144 input tokens per request. Against that one input, you can ask up to 1,000 independent questions of three kinds:

Yes/no (noul in the API) returns a probability between 0.01 and 0.99

Choice picks from 2 to 255 options and returns a probability for each

Score grades against an ordered rubric and returns a weighted score plus a probability per level

Every answer carries a confidence value, so your code can send uncertain cases to a fallback or a person.

The pricing is the pitch. You pay \$0.10 per million input tokens, the shared input is billed once no matter how many questions you ask, and output costs nothing because there is none. A no-cost tier in Google AI Studio covers prototyping.

The capability table shows what this model is not. Text generation, thinking, function calling, structured outputs, batch and caching are all listed as unsupported. It's a scoring engine, not a chatbot.

What Happened When We Ran It?

We installed Google's google-genai SDK, created a free API key in AI Studio and ran three tests: Google's quickstart, Google's image example from the launch post, and an ambiguous support message of our own. Latency was timed from our machine, so it includes the network round trip.

The quickstart asks two questions about one 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?"}, "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["queue"].choice, result.answers["queue"].confidence)

For the image test, input becomes a list holding an image URL and a text note. Here's what came back:

Damaged: 0.99. Queue: replacements (0.98)

"Charged twice, handle chipped"

Damaged: 0.99. Queue: replacements 0.50, billing 0.48

Spill: 0.95. Action: wipe with cloth (0.98). Severity: 1.19 of 2

Medians exclude each test's first call. Accuracy was clean: both of Google's examples came back right, and the image result matched Google's own screenshot. Every call billed zero output tokens. In dollars, the text query costs about \$0.000017 per call, roughly 58,000 calls for a dollar. The image query costs about \$0.00013.

Google Is Already Running on It

Google says four of its own products use the Decisions API:

Gemini Notebook routes each query to a model tier and thinking level, which Google says cuts latency on everyday queries by up to 40%

Stitch uses it in its rapid canvas experiment to build playable wireframes and apply voice or tap edits

CC from Google Labs picks an emoji reaction from more than 200 options without adding visible delay

Google Search uses it as a safety layer that checks Model Context Protocol tools for adversarial behavior

1. The Confidence Score Is the Real Product

Our ambiguous message is the test that matters. It fit two queues, and the model said so: 50.2% replacements, 48.4% billing, confidence 0.50. It didn't fake certainty on a coin flip, and in the same call it still rated the chipped handle as damage at 0.99.

One example doesn't prove calibration, which is measured across thousands of cases. But it's the behavior Google is selling, and it showed up when we went looking for it.

2. Read Confidence, Not Just Choice

Here's the trap. On that coin-flip message, the choice field still returned replacements, with no flag attached. Code that reads only the winner routes it as confidently as the clear case.

The calibration is only worth something if you set a threshold on confidence and send everything below it elsewhere. Google's quickstart prints the winner. Your production code shouldn't stop there.

3. The Speed Claim Didn't Hold for Images

Google quotes 150 to 250 ms end to end. After the first call, our text calls landed between 339 and 577 ms, a gap network distance can plausibly explain. Our image calls took 1.1 to 1.4 seconds, a median five to nine times the claim, though Google says its figures hold across multimodal inputs.

Some of that may be Google fetching the image from a URL and processing 1,064 image tokens. We can't separate the causes from outside. Two more details: Google's latency figure covers contexts up to 16K tokens, not the full 256K, and identical calls in our runs varied by more than 300 ms. Benchmark it on your own media before it goes anywhere near a real-time path.

4. The Benchmarks Are Google's Own

The "nearly 5x cheaper" figure compares Decision 1 with Google's own Gemini 3.5 Flash-Lite, on a benchmark suite Google chose. That's useful if you already run Gemini. It says nothing about how Decision 1 compares with a small fine-tuned classifier you already have.

5. Check the Small Print

The model page pitches classification over live media streams, while the same page lists the Live API as unsupported. And the model is Gemini-only for now. It's on OpenRouter, LangChain, Vercel's AI SDK, LiteLLM and others, but Google Cloud support is still marked as coming soon.

Decision 1 does one narrow job well. It's cheap, it was accurate on everything we gave it, and it admitted doubt when we pushed it. Use it for routing and policy checks now. Wire your code to confidence from the first day, and time it on your own images before you promise anyone 200 ms.

Shittu Olumide is a software engineer and technical writer passionate about leveraging cutting-edge technologies to craft compelling narratives, with a keen eye for detail and a knack for simplifying complex concepts. You can also find Shittu on Twitter.

原文为英文,正文由自动抓取并保留原文。

本文由采集器自动同步

原文发布于 KDnuggets(Introducing Gemini Decision 1: A Model That Picks Answers Instead of Writing Them),标题、摘要与正文由机器翻译,术语按行业惯例统一,未经人工逐句校订。

阅读原文 ↗