OpenAI's Decisions API Answers in 170 Milliseconds for $0.10 per Million. It Does Not Say How Often It Is Right.

Three weeks ago we wrote about Jev, TypeSafe AI's "decision model" that does not write prose: you send it a state and typed questions and it returns calibrated probabilities in a few hundred milliseconds for $0.042 per million input tokens. Vercel called it the fastest-adopted model in its Gateway's history. Today, October 6, OpenAI opened its answer to public beta.

The Decisions API is a dedicated endpoint, POST /v1/decisions, that runs a specialized version of GPT-6 Luna and returns typed answers instead of text: a probability that a predicate is true, a choice from a fixed list with a probability per option, or a score against ordered levels. OpenAI's guide says it answers "about 10x faster than the Responses API," and the price is $0.10 per million input tokens with output and cache tokens free. It was announced at DevDay on September 29 as a limited preview; today anyone with an API key can call it.

We read the guide, the changelog, the Python and Node SDK source, the pricing page, the rate-limits page, and the launch-day community thread. One thing is missing from all of them, and it is the only thing a decision model is for: any statement of how accurate or how well-calibrated the returned probabilities are.

What It Is, Priced

"Output free" is not a discount, it is the shape of the product. The endpoint returns numbers, not tokens, so there is nothing to bill on the way out. The comparison that matters is against GPT-6 Luna on the Responses API, which costs the same $0.10 per million input plus $0.50 per million output, and against Jev at $0.042 per million input with output also free. On input alone, OpenAI charges 2.4 times TypeSafe's list price.

"Cache tokens free" means there is no cache. The guide says there are no cache-read or cache-write charges, and the SDK exposes prompt_cache_key and prompt_cache_options parameters. We could not find any statement that caching exists for this endpoint, and the parameters' presence does not establish it. We print this as a gap today and return to it in the update below.

The docs disagree with the SDK on images. The guide: "Images must be inline base64 data URLs. Hosted HTTP or HTTPS image URLs and file_id inputs aren't supported by this endpoint." The Python and Node SDK docstrings: "Images can be base64 data URLs or publicly accessible HTTP(S) URLs." Both are OpenAI's documents, published the same day. Try base64 first.

The base model's own page does not list it. The gpt-6-luna model page has an 18-row endpoint table (Chat Completions, Responses, Batch supported; Live, Realtime, Embeddings, and the rest not), and Decisions is not a row. The guide says Luna is the only model; the model page does not say Luna supports it.

What Comes Back

The endpoint takes one input, text or text plus images, and a list of questions. Each question is one of three types, and each type returns a different shape.

A predicate question ("Was a refund issued?") returns a single probability from 0 to 1 that the condition is true. A choice question ("Which team should own this ticket?") returns the selected value, an array of probabilities across the options you supplied, and a confidence figure. A score question ("How severe is this incident?") takes an ordered list of levels and returns, in OpenAI's words, "the probability-weighted average of the level indices" plus the per-level probabilities and a confidence; the guide notes that "the returned score is a probability-weighted average, so it can fall between levels." Any question can also come back as a refusal.

Two design limits follow from that shape. All questions in one call are asked about the same input; there is no way to batch 200 unrelated tickets into one request, only 200 questions about one ticket. And the guide does not say how confidence is computed, which is the number most teams will branch on.

The comparison OpenAI invites is to the plain Responses API with a JSON schema, where you can get a label and a stated confidence from any model. The Decisions guide's answer is speed and the per-option probability array, and the only published argument for the probabilities being meaningful is that they are probabilities. We return to that in the scorecard.

The Speed Claims, Sorted by Who Measured Them

House rules: independent numbers first, vendor numbers labeled.

Independent, within hours of the beta. A published open harness by the developer Topfi ran 286 Decisions calls on launch day through OpenRouter's System One route against the same calls to Jev 1.13: Luna's median was 346 ms with a 95th percentile of 860 ms, against 311 ms and 517 ms for Jev; the Luna run cost $0.0600 against $0.0192 for Jev, a 3.1x ratio; and four Luna calls failed outright (two HTTP 503 "Decision inference is unavailable", two 502 refusals) against zero for Jev. Those numbers include a gateway hop, so they are an upper bound on OpenAI's own latency.

Independent, measured before the endpoint existed. On October 1, Ryan Porter at anth.us ran 3,600 ProofWriter reasoning problems through the standard API with gpt-6-luna at effort none and logprobs on, and compared the stated confidence to the hit rate: an expected calibration error of 0.32 for Luna against 0.03 to 0.04 for Jev, with Luna correct 68% of the time on the 2,672 answers where it stated 99% or more confidence. He is explicit that this "isn't the Decisions API itself," because OpenAI uses a specialized version of Luna behind it. It is the only calibration measurement of the underlying model that exists today, and it is the number the Decisions guide needs to answer.

Now OpenAI's numbers. The guide's first sentence is "about 10x faster than the Responses API." The changelog says "10x faster." The @OpenAIDevs post and the community announcement say "up to 10x faster than GPT-6 Luna through the Responses API." The "150 milliseconds versus 1.6 seconds" figure that most press printed is not in any OpenAI document; it comes from a bar chart in the DevDay keynote, reproduced by The Decoder, whose image alt text reads, in German, that the Decisions API takes 150 milliseconds and the GPT-6 Luna API 1.6 seconds. OpenAI's Thibault Sottiaux put it on X as "tuned to be able to make decisions in less than a few hundreds of milliseconds end to end." So: about 10x is the vendor claim, 150 ms is a chart read, and a few hundred milliseconds is what the launch-day harness saw.

Three honest observations:

• There is no accuracy number anywhere. The guide has no section on calibration, evaluation, or how confidence is computed. Jev's manifesto is about calibration; OpenAI's guide is about latency. For a product whose entire output is a probability, that is the gap to watch.
• The rate limits are Luna's, not the endpoint's. No Decisions-specific limits are published. GPT-6 Luna's are 5,000 requests per minute and 2 million tokens per minute on the Build tier, 10,000 and 10 million on Launch, 30,000 and 180 million on Grow. The changelog says OpenAI simplified usage tiers "from five to three" today; the rate-limits page lists four, including a Free tier.
• Not on Azure. Microsoft Foundry has gpt-6-luna for Responses and Chat Completions only. If you need Decisions behind a Microsoft contract, you are waiting.

How It Compares With Jev, on Paper

The two real differences are context and images. Jev is text-only with a 32K window; Luna brings a million tokens and vision. If your decision is "does this screenshot show a checkout error," only one of these can answer it today. If your decision is "route this ticket," both can, and one costs 2.4x the other before you count calibration.

Where You Can Run It

OpenAI's API directly, with the Playground at platform.openai.com/decisions. Vercel AI Gateway as openai/gpt-6-luna-decisions at the same $0.10 per million, through the AI SDK's experimental_decide, alongside Jev, Microsoft Decision-1, Laya, and Liquid d1 on the same /v1/decisions gateway endpoint. OpenRouter through its System One route, not its chat catalog. Not Azure, not Bedrock, not Vertex.

Verified vs Unconfirmed: The Scorecard

Who Should Use It

Use the Decisions API if your routing, classification, or guardrail step needs vision or a long context, and you can measure its calibration yourself before you trust the probabilities. Send 200 questions per call against one input, keep images inline as base64, and log confidence against outcome from day one, because nobody else has.

Skip it for text-only routing where Jev already works: it is 2.4x the input price with no published calibration advantage, and the one measurement of the underlying model says it is far worse calibrated. Skip it for anything that needs a cache, a batch discount, an Azure endpoint, or a GA price; none exist today.

The frontier is elsewhere: this is a Luna-class model (38 on the Artificial Analysis Intelligence Index) with a fast typed interface, not a reasoning model. If the decision is hard, Claude Opus 5.5 or GPT-6.1 Sol on a normal endpoint will get it right more often and cost more doing it. Our model comparison has the current standings side by side.

Update, October 16, 2026

• October 7: An OpenAI community staff account confirmed in the launch thread that "there's currently no caching available for the Decisions API," which settles the cache question: the free cache tokens are free because there are none. In the same forum, Armin Catovic published 1,000-trial toy experiments showing choice probabilities of 98/2 on a coin described as 70/30, choice probabilities shifting by up to 15 points when option order changed, and score-type probabilities that "sum above 100%"; the staff account acknowledged the thread and no guidance followed. A Hacker News commenter measured 160 to 175 ms end to end calling OpenAI directly, with a worst 5% of 285 ms.
• October 8: Abnormal AI tested 40 models on 1,985 synthetic security emails and called the Decisions API "the standout, catching most of what luna-6-max does at a fraction of the cost and latency," and rated the decision APIs "among the best calibrated" on its task, with Jev best. Calibration is task-dependent; this is the counterweight to Catovic's coin.
• October 11: Topfi reproduced the bad tag probabilities against OpenAI's API directly, which rules out OpenRouter as the cause, and shared the cases with OpenAI's Brian Yu. OpenAI's Python SDK 3.29.0 "clarified Decisions question and answer descriptions"; the base64-versus-HTTP(S) image contradiction survived the clarification.
• October 13: Artificial Analysis launched a Decision Index (v1.0) that scores the endpoint directly: GPT-6 Luna (Decisions) 48.5, eleventh of 13 decision models, behind Liquid d1-ultra 65.3, Jev 1.13 at 57.5, Jev 1.14 at 57.1, Microsoft-Decision-1 at 53.8, and Mercury Decide at 52.7, at 168 ms mean per task and $78.9 per million tasks against Jev's $41.5. It scores 1.1 points below GPT-6 Luna run as a plain LLM without reasoning (49.6). AA's calibration bins show the Decisions variant 87.9% correct on answers given at about 0.978 confidence overall, and 7.4% correct on HLE multiple-choice answers given at 0.953 confidence.
• October 14: TypeSafe released Jev 1.14 as jev-preview with flag-gated image input; AA scores it 57.1 at 78 ms per task.
• October 15: OpenAI added native Decisions delegation to GPT-Live sessions, so a voice app can call Decisions while the user is still speaking. The Decisions API is still in beta with no GA date and no GA price.

Sources

• OpenAI docs: Decisions API guide
• OpenAI API changelog
• OpenAI API pricing page
• OpenAI Python SDK: decision_create_params.py
• OpenAI developer community: Decisions API launch thread
• anth.us: OpenAI Decisions API preview and Luna calibration
• Topfi: Classifier-Eval results
• Artificial Analysis: Decision Index
• Abnormal AI: Classifying emails with Jev and the OpenAI Decisions API

*Not sure whether a decision model belongs in your stack, or whether a normal model with a schema does the job? Take the free 2-minute quiz and get matched. Then read the model that landed a week before this endpoint and made GPT-6 Sol obsolete in seven days: GPT-6.1 Sol.*