OpenAI Decisions API

Status: Generally available since October 22, 2026, after a public beta that began October 6.

A different kind of output

Most AI APIs are built to write. You send a prompt and get back an explanation, a draft, or some code. A lot of real application logic does not need any of that. It needs a decision: which queue does this support ticket go to, is this message spam, which of three agents should handle this request, how risky is this transaction on a scale of one to five.

Developers have been getting those decisions by asking a chat model to “answer only with A, B, or C” and then parsing the result. It works, mostly, but you pay for generated text you throw away, the output occasionally breaks your parser, and you get no sense of how sure the model was.

The Decisions API skips the writing. You describe the question and the allowed answers, and it returns a typed answer with probabilities attached. OpenAI announced it as a public beta on October 6, 2026 and moved it to general availability on October 22.

The three question types

Every request contains shared input (text, images, or JSON) and a list of questions. Each question has a name, instructions, and one of three types.

A predicate asks whether a statement is true. The answer is a probability from 0 to 1. “Does this email request a refund?” might come back as 0.91.

A choice picks one option from a list you supply, each with a value and a description. The answer includes the selected value, a probability for every option, and a separate confidence figure. This is the natural fit for routing: pick a department, a model tier, or a tool.

A score rates the input against ordered levels you define, from two to ten of them. The returned score is a probability-weighted average of the levels, so it can land between them, along with per-level probabilities. This suits severity, priority, and quality ratings.

You can ask up to 400 questions about the same input in one request, which is useful when one document needs to be checked against many criteria at once. The API returns only typed answers; your code decides what to do with them.

Where it fits

Small conceptual examples help:

• A support system asks one choice question (“billing, technical, account, other”) and one score question (“urgency, 1 to 4”) about each incoming ticket, then routes it.
• An agent framework asks which of four tools to call next, using the choice probabilities to decide whether it is confident enough to proceed or should escalate.
• A model routing layer asks whether a request is simple enough for a cheap model, and sends anything below a threshold to a stronger one. That is the core of model escalation.
• A content team scores incoming drafts against a rubric before a human reviews the borderline ones.
• A sales team ranks leads by asking several predicates about each one.

OpenAI also added native GPT-Live integration at GA, so voice applications can make decisions while someone is still speaking.

Pricing and why the structure matters

Uncached input costs $0.10 per million tokens, and output tokens are free, which makes sense because there is almost no output. Prompt caching was added at GA: shared input is cached by default once the reusable prefix is at least 1,024 tokens, cache reads are discounted, and cache writes are charged. Regional processing in the US and Europe, long-context multipliers, and Zero Data Retention eligibility are covered in OpenAI’s pricing and data docs.

Per-token price is only part of the picture. A decision that is wrong 5% of the time and silently routes a refund request to the wrong team has a cost that never shows up on the API bill. The more useful number is cost per completed task: API spend plus the cost of retries, escalations, and human fixes.

Evaluate before you automate

OpenAI’s own guide is direct about this: set thresholds using labeled examples from your application, and choose them based on what a false positive costs you compared with a false negative. It also says to treat the confidence field as a separate signal from the probability distribution.

Community testing during the beta supports that caution. Developers found that choice questions produced more extreme probabilities than predicates on the same underlying question, and that changing the order of options shifted the results. One developer also reported more confident wrong answers on nuanced judgment calls than with a competing decision model. These are anecdotal, not formal benchmarks, but they point to the same practice: build a small labeled test set, measure it, and gate your automation on the results. Our evaluation-gated routing entry covers the idea.

Limitations

• Only one model, GPT-6 Luna, is supported. You cannot point it at a larger model for harder judgments.
• Files, audio, and stored item references are not accepted as input.
• It returns typed answers only. For generated objects or tool-call arguments, OpenAI points you back to Structured Outputs or function calling in the Responses API.
• Dependent logic, where one answer changes the next question, needs separate requests in sequence.
• OpenAI says decisions are around 10x faster than the equivalent Responses API call, but publishes no latency guarantee.

Alternatives

• A small classifier model via OpenRouter with constrained output, if you want to choose the model yourself
• Inception’s Mercury Decide, a decision model from the makers of Mercury 3 aimed at high-volume classification
• Cheap general models such as MiniMax M3.1 Flash or DeepSeek V4.1 Flash, prompted to classify, when you also need explanations

For the general concept, see decision model. For the wider strategy, see Why You Need More Than One AI Model and How to Make Cheaper AI Models Work Smarter.