The Decisions API entered public beta on October 6, 2026, as OpenAI announced: the new interface that was only a limited preview at DevDay on September 29 is now open to all developers, with official documentation and a debugging Playground live on day one, and general availability expected in the coming weeks. It does something narrow — it generates no text at all. It only answers questions, and only by choosing from answers the developer provides.
Three question types: judge, choose, score
A Decisions request has three parts: the model, the input as evidence (text, images, or both), and a set of questions. The only model currently available is gpt-6-luna, called through the dedicated /v1/decisions endpoint. Questions come in three types: predicate, which returns the probability (0 to 1) that a condition holds — for example, whether a product in a photo shows visible damage; choice, which picks one value from a fixed set supplied by the developer and returns a probability distribution over the options, suited to unordered sets like departments or categories; and score, which faces ordered levels such as issue severity and returns a probability-weighted average that can fall between levels.
OpenAI's speed figure: the same kind of judgment runs about 10x faster than through the Responses API. The reason is straightforward — a conversational interface must generate an answer word by word and leave the application to parse text back into structure, while Decisions outputs probabilities and selections directly, skipping generation and parsing alike. The official use cases are content classification, request routing, work prioritization, and letting an agent decide its next action.
Not the same thing as structured outputs
It is easy to confuse this with the Responses API's existing structured outputs and function calling. OpenAI draws the boundary explicitly in its docs: use structured outputs when you need fields extracted into your own JSON schema or explanatory text generated; use function calling when the model must initiate a tool call with arguments; use Decisions when all you need is a judgment, a choice, or a score that can drive a program branch directly. In other words, it splits out the most frequent, least literary class of calls in an application and trades generation ability for latency and determinism.
Decision models are becoming a category of their own
The timing is worth noting. On the very day OpenAI announced the beta, Perplexity cut the price of its own Decision API in half — two companies sparring within hours shows that "models that only judge" have moved from niche experiment to open battlefield. In the weeks before, startups such as TypeSafe had already shipped judgment-specialized models. The logic is cost: a large share of production calls never needs a flagship model writing prose — they just assign a ticket to the right team, tag content correctly, or decide which step an agent takes first. These calls are high-volume, latency-sensitive, and limited in answer space, which suits a small model behind a dedicated interface. This site previously mapped the GPT-6 family's three tiers of pricing and roles; Luna, the model Decisions runs on, is the family's lightest and cheapest tier, and recasting it from chat model into judgment engine is a natural extension of that line.
For developers, the switching cost is low: systems with existing classification or routing logic can run real traffic against it and compare latency and accuracy before committing. The gaps to watch: separate pricing has not been published, Luna is the only model available for now, and the calibration of its probability outputs has to be validated on your own data — OpenAI provides the interface; whether the judgments are right is something your own tickets and content must prove.
