OpenAI's Decisions API Trades Prose for Probability — 10x Faster Calls

OpenAI's Decisions API is exactly what it sounds like: a dedicated endpoint for machine decisions, not conversation. Announced at DevDay 2026 and in public beta since October 6, it routes requests to the gpt-6-luna model through POST /v1/decisions and returns typed answers — probabilities, choices, scores — instead of token-by-token prose. OpenAI claims up to 10x the speed of the Responses API on the same model. If you build systems that classify, route, or filter at scale, this is the most practically useful thing to come out of DevDay.

How the OpenAI Decisions API works

You define the exact decision you need, in a structured schema, and the endpoint runs gpt-6-luna — the API is powered exclusively by that model — returning a typed answer directly. No streaming tokens, no wrapping output in JSON, no regex-ing a paragraph to extract the one word you actually wanted. The speed claim comes from cutting out output-token generation entirely, which is also the expensive part of most API bills. Latency drops because there is nothing to decode, and cost drops because you stop paying for tokens you never wanted.

The three question types

The API handles three kinds of decisions, and the taxonomy is more useful than it sounds:

• Predicate — a 0–1 probability for a yes/no question. Example: is there visible damage in this product photo? Feed it into returns triage, fraud flags, or content filters.
• Choice — pick from an unordered list, with a probability and confidence per option. Example: route this support ticket to billing, technical support, or account security. Confidence scores let you automate the obvious cases and kick the uncertain ones to a human.
• Score — a probability-weighted average over ordered levels. Example: severity ratings on a security finding, or quality scores on user-generated content. This is the one people will reach for first, because ordinal scores are what most pipelines actually consume.

Where it fits in your architecture

Think of this as a decision layer that sits in front of your generation layer. Use the Decisions API as triage: classify, route, filter, and score every request cheaply, then invoke the heavy generative model only for the cases that actually need prose. Set confidence thresholds as policy: high-confidence decisions auto-execute, low-confidence ones escalate to a human or a larger model. This is the same pattern behind structured extraction APIs and Google's developer knowledge tooling — the generative model is the expensive last resort, not the first call in the chain. If your pipeline currently sends every request through a big model and parses the answer, you are paying the maximum price for the minimum structure.

The economics: output tokens were the tax

For infrastructure processing tens of thousands of requests a day, dropping output-token generation changes the math completely. Classifying with a chat model means paying for hundreds of output tokens per request just to get a label back. A typed probability is a fraction of that. It is also more deterministic in practice: you get a number and a confidence value, not a paragraph that hedges for two sentences before committing. Over a month of production traffic, the difference between "cheap, typed, fast" and "expensive, prose, slow" is the kind of line item that shows up in a cost review.

What to watch out for

It is a beta, so treat it like one. Probabilities from a model are not calibrated probabilities — you still need evals on your own data, and you need a plan for what happens at the confidence boundaries. Vendor lock-in is also real: gpt-6-luna only, a closed endpoint, not a portable standard. Build your decision layer as an interface, not as an OpenAI dependency, so you can swap the provider later. And note the broader context: DevDay also shipped the Agents API with Computer Use and Codex Security Cloud. The industry is splitting between lightweight structured-decision models and generative chat models, and GitHub's AI scan going GA for pull requests is another flavor of the same move — automated judgment calls inside the developer workflow, not prose about prose.