Two months ago there was one decision model you could call: TypeSafe's Jev. Now the big labs ship their own. OpenAI put a Decisions API on gpt-6-luna in October, and Google launched Gemini Decision 1 on 11 November 2026. All three do the same job. You send some input and a few typed questions, and you get back a probability for each answer instead of generated text.
I wrote about the idea itself in LLMs vs Jev vs CDMs. This post is the practical follow-up. If you build routing, triage or moderation, which of the three hosted APIs should answer the call? I read all three sets of docs, wrote one adapter that talks to all of them, and collected the independent tests that exist so far. Vendor numbers are marked as vendor numbers.
The same question on all three APIs. Only the field names change.
The short version: they are close on the idea and apart on the details. Jev is the cheapest. Gemini takes the most kinds of input and the most questions per call. OpenAI fits best if you already run on OpenAI and want images and an explicit refusal. None of them should decide anything that needs reasoning.
What a decision model returns
A chat model writes its answer one token at a time, even when the answer is one word. A decision model reads the input once and scores a fixed set of answers you defined. There are three question shapes, and all three APIs support them:
- Yes/no. Returns P(yes) between 0 and 1. TypeSafe and Google call this
noul. OpenAI calls itpredicate. - Choice. Picks one option from a list you give, with a probability for every option. Up to 255 options on all three.
- Score. Places the input on an ordered scale you describe, such as cosmetic, workaround, fully blocked. The returned score is the probability-weighted position on that scale, so 1.1 means "mostly level 1, a bit of level 2".
Every question in a request sees the same input, and no question can see another one's answer. If question two depends on question one, that is two requests. All three docs say this.
Jev: the original, and still the cheapest
TypeSafe launched Jev on 15 September 2026 and shipped Jev 1.14 on 14 October. You POST to https://api.typesafe.ai/v1/systemone with a state and a map of questions keyed by your own ids. Jev 1.14 adds a fourth type, box, which finds something in an image and returns its edges as fractions of the width and height.
jev-request.json
{ "model": "jev-latest", "state": "Our API started returning 500 errors 20 minutes ago and we can't process orders.", "questions": { "department": { "type": "choice", "instructions": "Which team should handle this", "criteria": { "billing": "Payment or subscription issues", "technical": "Bugs or integration problems", "sales": "Pricing or account questions" } }, "is_urgent": { "type": "noul", "instructions": "The message conveys urgency" } } } The response is a map with the same keys. A choice answer carries choice, probabilities and confidence. A noul answer is a single number with no confidence field.
Pricing is $0.042 per million input tokens, and output is free. The default limit is 64K tokens per request and 32K per question. You can raise both to 262K with a header literally named TypeSafe-Danger-Zone-Long-Context: true, which the docs describe as slower and less accurate. Inputs are text and PNG or JPEG images. It is still labelled early access.
One cost detail is easy to miss. In Opper's Jev vs Kev test, Jev counted about 257 extra input tokens on every request: a one-line message with one question billed 280 tokens on Jev and 23 on Kev. On long inputs that overhead disappears into the noise. On millions of one-line messages it is most of your bill.
OpenAI Decisions: the same idea, different names
OpenAI's version lives at POST /v1/decisions, and gpt-6-luna is the only model it supports. The guide now calls it generally available. The shape is the most different of the three. Questions are an array, each with an optional name, and answers come back as an array in the same order.
openai-decisions.sh
curl https://api.openai.com/v1/decisions \ -H "Content-Type: application/json" \ -H "Authorization: Bearer $OPENAI_API_KEY" \ -d '{ "model": "gpt-6-luna", "input": "The package arrived with a broken screen.", "questions": [ { "type": "predicate", "name": "damaged", "instructions": "Does the customer report a damaged item?" } ] }' openai-response.json
{ "model": "gpt-6-luna", "answers": [ { "type": "predicate", "name": "damaged", "probability": 0.95 } ], "usage": { "input_tokens": 42, "output_tokens": 0, "total_tokens": 42 } } Choice options are a list of {value, description} objects, and a value can be a boolean. Score levels are {label, description}, from 2 to 10 of them. You can send 1 to 400 questions per request, up from 200 during the beta. The input can be a string, a message array, images by URL or base64, or JSON through input_json.
Two things only OpenAI has. A question can come back as {"type": "refusal"}, so your code has to handle a missing answer. And prompt caching works here too, for a shared prefix of at least 1,024 tokens, which matters when you ask many questions about the same long document.
Price is $0.10 per million uncached input tokens, and output is not charged. OpenAI says it is "about 10x faster than the Responses API" and gives no millisecond figure.
Gemini Decision 1: the most inputs, the most questions
Google's model is gemini-decision-1 at POST https://generativelanguage.googleapis.com/v1beta/decisions, with the API key in an x-goog-api-key header. The request uses input like OpenAI but keeps TypeSafe's map of questions and the noul name. In practice it is closer to Jev's format than to OpenAI's.
gemini_decision.py
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?", }, }, ) # {"answers": {"is_damaged": {"type": "noul", "noul": 0.99, "confidence": 0.99}}, ...} It accepts the widest range of input: text, JSON, images, audio, video and PDF. It also allows up to 1,000 questions per request, all inside one 262,144-token window. Google's blog post quotes 50 to 100 ms of model compute and 150 to 250 ms end to end, "nearly flat from 1 to 100 questions". A test post on Google AI's own dev.to account measured about 180 ms for one question and about 250 ms for 100.
The limits are worth reading before you build on it. It is v1beta. Question instructions are text only. There is no context caching, no Batch API and no conversation history. A noul value is clamped between 0.01 and 0.99, so it never says 0 or 1. Safety filters reject the whole request with HTTP 400 instead of answering. Price is $0.10 per million input tokens, with a free tier in AI Studio.
Google says Gemini Decision 1 beat Jev and OpenAI's API on seven of nine benchmarks it ran, and that Jev was slightly more cost-efficient. Those are Google's own benchmarks.
Price, limits and status side by side
Everything that differs, in one place. Checked against each vendor's docs on 20 November 2026.
You pay for what you send. The answer is free everywhere.
Because output is free, cost is just input tokens times price. Say you route 10,000 support tickets of about 500 tokens each, so 5 million tokens. That comes to $0.21 on Jev and $0.50 on either OpenAI or Gemini. Add Jev's roughly 257-token overhead per request and Jev rises to about $0.32, still the cheapest. At this scale none of them is expensive. The gap only matters at hundreds of millions of calls.
What the independent tests say
Independent numbers are still thin, so here is what exists, with who ran each test.
JevMan: real-time choices
Opper runs a Pac-Man benchmark called JevMan. At each junction the model gets the maze as state and returns a probability for each direction, and any answer slower than 2 seconds is replaced by a fallback rule. Over 100 games each, Jev 1.14 tied for first with a mean score of 3,597. Gemini Decision 1 was 9th at 2,964, and GPT-6 Luna Decisions 11th at 2,568. GPT-6 Luna had the fastest mean answer of the three, at 179 ms, against 252 ms for Jev and 268 ms for Gemini. Opper sells access to all of these models, so read it as a well-documented vendor test, not a neutral one.
Requesty: decision models against frontier LLMs
The most useful test so far comes from Requesty, an LLM gateway, which sent about 22,000 decisions on 5 October 2026. It did not test the three APIs in this post, but it compared open decision models (Cloudflare's Clef and Perplexity's Decider) with Claude Opus 5.5 and GPT-5.5 on the same questions. The pattern should carry over to any model of this type.
Filtering is a strength. Judging whether a tool call is needed is not.
- On moderation, the decision model matched or beat Opus. Clef scored 87.0% on unsafe-prompt detection against 84.5% for Opus, at about 3% of the cost.
- On deciding whether a tool call was needed, both decision models scored 68.7% against 90.0% for Opus. That question needs reasoning about the request, and a single read cannot do it.
- Ordered scales were about 10 points weaker than yes/no questions on every decision model. If you can ask yes/no, do.
- Decision models never failed to answer. Hosted GPT models refused or were filtered on 33 to 36% of the toxic prompts.
Requesty also found that the confidence field is not portable. The same weights served by two providers returned different confidence numbers, and Perplexity's matched its own top probability on only about a quarter of items. Set thresholds on the probabilities, not on confidence. The three APIs here do not even define it the same way: Jev uses (p_max - 1/n) / (1 - 1/n), Gemini uses the top probability, and OpenAI omits it on yes/no answers.
Wording matters more than the model
Two separate tests, same lesson: the question is part of the model.
In one hands-on test of a small open decision model, rewording a yes/no question moved P(yes) on a true case from 0.209 to 0.912. In that same Google AI post, one broad routing question scored 0.72, and splitting it into four or five narrow questions scored 0.88. Earlier research on Jev and similar models found that swapping which name, yes or no, was bound to which definition pushed mean AUC below chance. Three habits follow:
- Ask narrow, atomic questions and combine the answers in code.
- Give every option a description, and add an "other" option to choices. Gemini's docs warn that a choice always spreads probability across your options even when none fits.
- Never ask a negated question. "Is this not spam?" is a reliable way to get the opposite of what you meant.
One adapter for all three
Since the three APIs share one idea and differ only in names, I wrote a small adapter so a feature can switch vendors with one argument. It maps a neutral question list to each wire format and turns every response into the same shape. It also computes its own margin, the top probability minus the runner-up, so thresholds mean the same thing on every vendor.
decide.ts
// One question spec, three decision APIs. Field names follow each vendor's docs (Nov 2026). export type Question = | { id: string; kind: 'yesno'; text: string } | { id: string; kind: 'choice'; text: string; options: Record<string, string> } | { id: string; kind: 'score'; text: string; levels: string[] } export type Answer = { id: string value: boolean | string | number // yes/no, chosen option, or score on 0..levels-1 probs: Record<string, number> // option or level index -> probability margin: number // top probability minus the runner-up, computed here } export type Vendor = 'typesafe' | 'openai' | 'gemini' export function buildRequest(vendor: Vendor, input: string, qs: Question[]) { if (vendor === 'openai') { return { url: 'https://api.openai.com/v1/decisions', headers: { Authorization: `Bearer ${process.env.OPENAI_API_KEY}` }, body: { model: 'gpt-6-luna', input, questions: qs.map((q) => q.kind === 'yesno' ? { type: 'predicate', name: q.id, instructions: q.text } : q.kind === 'choice' ? { type: 'choice', name: q.id, instructions: q.text, choices: Object.entries(q.options).map(([value, description]) => ({ value, description })), } : { type: 'score', name: q.id, instructions: q.text, levels: q.levels.map((label) => ({ label, description: label })), }, ), }, } } // TypeSafe and Gemini both take a map of questions keyed by id. const questions = Object.fromEntries( qs.map((q) => [ q.id, q.kind === 'yesno' ? { type: 'noul', instructions: q.text } : { type: q.kind, instructions: q.text, criteria: q.kind === 'choice' ? q.options : q.levels }, ]), ) return vendor === 'typesafe' ? { url: 'https://api.typesafe.ai/v1/systemone', headers: { Authorization: `Bearer ${process.env.TYPESAFE_API_KEY}` }, body: { model: 'jev-latest', state: input, questions }, } : { url: 'https://generativelanguage.googleapis.com/v1beta/decisions', headers: { 'x-goog-api-key': process.env.GEMINI_API_KEY ?? '' }, body: { model: 'gemini-decision-1', input, questions }, } } const margin = (p: Record<string, number>) => { const [a = 0, b = 0] = Object.values(p).sort((x, y) => y - x) return a - b } type Raw = any function fromYesNo(id: string, pYes: number): Answer { const probs = { yes: pYes, no: 1 - pYes } return { id, value: pYes >= 0.5, probs, margin: margin(probs) } } export function parseResponse(vendor: Vendor, json: Raw): Answer[] { if (vendor === 'openai') { return json.answers .filter((a: Raw) => a.type !== 'refusal') .map((a: Raw) => { if (a.type === 'predicate') return fromYesNo(a.name, a.probability) const probs = Object.fromEntries(a.probabilities.map((p: Raw) => [String(p.value), p.probability])) return { id: a.name, value: a.type === 'choice' ? a.choice : a.score, probs, margin: margin(probs) } }) } // TypeSafe and Gemini: answers is a map keyed by question id. return Object.entries(json.answers).map(([id, a]: [string, Raw]) => { if (a.type === 'noul') return fromYesNo(id, a.noul) return { id, value: a.type === 'choice' ? a.choice : a.score, probs: a.probabilities, margin: margin(a.probabilities) } }) } export async function decide(vendor: Vendor, input: string, qs: Question[]): Promise<Answer[]> { const req = buildRequest(vendor, input, qs) const res = await fetch(req.url, { method: 'POST', headers: { 'Content-Type': 'application/json', ...req.headers }, body: JSON.stringify(req.body), }) if (!res.ok) throw new Error(`${vendor}: HTTP ${res.status} ${await res.text()}`) return parseResponse(vendor, await res.json()) } I checked the mapping with a small Node assert script against the example requests and responses printed in each vendor's docs, including OpenAI's refusal case. The calls are the documented ones, but run your own labelled set before you trust a threshold.
route-ticket.ts
import { decide } from './decide' export async function routeTicket(ticketText: string) { const answers = await decide('gemini', ticketText, [ { id: 'urgent', kind: 'yesno', text: 'Is the customer blocked right now?' }, { id: 'team', kind: 'choice', text: 'Which team should handle this ticket?', options: { billing: 'Payments and refunds', technical: 'Bugs and errors', other: 'Anything else' }, }, ]) const team = answers.find((a) => a.id === 'team')! // Below the margin a person decides, not the model. if (team.margin < 0.3) return { queue: 'human' } return { queue: team.value as string } } Which one should you use?
Four questions, in order.
- Jev for high-volume text or JSON decisions where price per call matters. It has the most mileage, has the best JevMan score, and costs less than half of the others. Watch the per-request token overhead on very short inputs, and remember it is still early access.
- Gemini Decision 1 when the input is a PDF, a call recording, a screenshot or a video, or when you ask hundreds of questions about one document. It is the only one of the three that takes audio, video and PDF. It is also v1beta, so budget for changes.
- OpenAI Decisions when your stack, billing and data agreements already sit with OpenAI, or when you need prompt caching on a long shared prefix and an explicit refusal answer.
- None of them when the answer needs reasoning, such as whether an agent should call a tool or which of two good answers is better. Use an LLM there.
If you must keep data in-house, the open-weight models are the fallback: Cloudflare's Clef (27B, Apache-2.0), Perplexity's Decider and Jared Palmer's 4B Kev all accept a Jev-style request. That is a different trade, with a GPU to run, and a topic for another post.
Frequently asked questions
What is a decision model?
A decision model reads an input once and returns a probability for each answer you defined, such as yes or no, one option from a list, or a level on a scale. It writes no text, so it is faster and cheaper than an LLM for narrow questions.
Is Jev better than OpenAI Decisions?
On price, yes: $0.042 per million input tokens against $0.10, and on Opper's JevMan benchmark Jev 1.14 scored 3,597 against 2,568 for GPT-6 Luna Decisions. OpenAI's API answered faster in that test and offers prompt caching, image input and an explicit refusal answer.
What does Gemini Decision 1 do that Jev cannot?
It accepts audio, video and PDF input, and up to 1,000 questions in one request inside a 262,144-token window. Jev takes text and PNG or JPEG images, with 64K tokens per request by default.
Why does the yes/no type have different names?
TypeSafe named it noul and Google kept that name. OpenAI calls the same thing predicate and returns the value in a probability field instead of noul.
Can I use the confidence field as a threshold?
Not across vendors. Each one computes confidence differently, and one benchmark found it differs ev...





