OpenAI Decisions API: what Luna can decide for you
OpenAI Decisions API lets Luna choose from answers you define using text or images. Here's what the announcement confirms, what's missing and how to prepare a routing test.
OpenAI Decisions API can take text or images and choose from answers you define. Previewed at DevDay on September 29, 2026, it makes a narrow judgment quickly, then hands the result back to ordinary software.
The integration details are thin. As of September 30, the official recap describes the product and rollout, but gives you neither a dedicated price nor a request example. You can design your decision points now; production plans still need to follow the documentation OpenAI publishes.
OpenAI Decisions API picks from your answer set
The official DevDay recap says the API focuses Luna on questions with answers defined in advance. You supply text or image context and get answers for classification, request routing or an agent's next action.
Suppose your support app has a fixed set of queues and needs to decide where a message belongs. A useful answer might be billing, account_access, technical_support or needs_review.
These labels illustrate the idea; they aren't OpenAI's published request format. You decide which answers exist, and the model evaluates the incoming context against those choices.
Your app still loads the message, supplies relevant account state, receives the decision and dispatches the correct handler. Choosing a label won't retrieve a missing invoice or establish that a user has permission to change an account.
You can test that decision point as a small component of its own. Burying it in a long prompt that also drafts replies and runs tools makes the job harder to isolate.
Queues, tools and other jobs with fixed choices
OpenAI names broad uses rather than finished industry solutions. These examples show how you could map them onto application code, with a choice set and a handler for each job.
| Job | Illustrative answer set | What code does afterward |
|---|---|---|
| Support classification | Billing, account access, technical support, review | Assigns the ticket to a queue |
| Model routing | Simple answer, specialist, deeper reasoning, clarification | Calls the chosen handler |
| Agent control | Retrieve, inspect result, ask user, stop | Runs an allowed next step |
| Content screening | Pass, hold for review, reject | Applies the application's policy |
Define the labels carefully. An account access complaint might mention an unpaid invoice: which issue takes priority? A tool selector also needs to know what information is already available and what it is allowed to request.
For content screening, test whether the classification errors are acceptable for your policy. The possible use doesn't establish Decisions API as a validated moderation service. Speed alone won't make the label useful.
If you need a newly written explanation, code or a plan with unknown steps, a finite answer set can't supply the whole result. Use the decision to select the next component. Let a generative model handle the writing.
Image input could save you a conversion step
OpenAI explicitly includes image input in the announcement. For screenshots, scanned forms or visual application state, that could save you the extra component needed to convert everything into text.
The recap gives no task-specific image accuracy figures or reproducible visual routing examples. You know the input type is supported; you still need to measure how well Luna handles your actual decision.
For a document workflow, keep choosing a category separate from extracting the contents. The category may have a closed answer set, while the names and values inside usually don't. Combining the jobs into one vaguely defined decision makes evaluation harder.
A fraction of a second still needs a workload test
In his first-hand DevDay live blog, Simon Willison recorded the keynote description that the model responds "in a fraction of a second." He also immediately connected the feature to Jev, TypeSafe AI's recently launched decision model.
You can see the appeal: agent apps make many small judgments where waiting for a long answer feels wasteful. Faster decisions could make those paths more responsive.
The stage description isn't a latency guarantee. A published Decisions API latency distribution, test workload and independent comparison remain unconfirmed in the sources reviewed. You still need to know how it behaves with long inputs, simultaneous requests and clients far from its servers.
Measure the whole request from your app, including network time, preprocessing, queueing and fallbacks. Record the median and slower cases. If a mistaken route triggers another model call, count that delay too; the fastest successful response won't tell you much about it.
Time the path to a correct, usable action. A quick wrong label can leave your user waiting longer than a slower correct one.
OpenAI Decisions API pricing is still missing
There is no separate Decisions API price in the DevDay recap. The official API pricing page lists these regular GPT-6 Luna rates for standard processing with short context:
| Regular Luna token type | Price per million tokens |
|---|---|
| Input | $0.10 |
| Output | $0.50 |
These prices belong to the underlying model. Decisions API's billing remains unconfirmed: it could use those rates, a different token calculation or another unit.
A precise cost-per-decision comparison has to wait for the tariff. Once it appears, compare billed requests for the same task. Prompt length, required context and fallback frequency can matter more than the headline input rate.
In your budget today, keep regular Luna usage and prospective Decisions usage as separate line items. Mark Decisions pricing as pending. Copying the regular model price into the estimate would make an unresolved cost look settled.
Preview access doesn't give you an integration contract
OpenAI's recap describes limited preview access at launch, with broad release planned for the coming days. There's no dated general availability commitment, and the plan doesn't mean your account already has access.
Official documentation searches found the product description but didn't confirm a dedicated public Decisions API reference. The announcement supplies no endpoint, authentication example or request and response schema.
The GPT-6 Luna model page documents regular Responses API and Chat Completions support, including structured outputs. You can't infer a Decisions API call from those capabilities.
An example using decisions.create may look plausible, but that method name is invented. Build a local interface for choosing a handler now. Implement the provider adapter when you have the real contract.
Give the preview an existing router to beat
Start with a decision your app already makes. Assigning a support queue is easier to assess than choosing the best action for an entire business process.
Write the allowed answers and their boundaries. Give missing information and requests outside your supported scope an explicit route, with a real handler that asks for clarification or sends the case for review.
Collect representative examples and label the correct outcome before comparing models. Include neighboring categories, mixed requests and wording that could push the system toward the wrong queue.
Evaluate routing separately from the final reply. A downstream model can produce a good response despite a poor route, especially when it compensates for missing context.
Use a regular small model with a strict enum as your baseline. OpenAI's Structured Outputs documentation already describes schema-conforming responses and programmatic refusal handling. You don't inherently need formatting retries with that feature, though semantic mistakes remain possible.
When Decisions API becomes accessible, you can test whether it improves the accuracy, delay or cost of that existing path. Keep a working router until the measurements give you a reason to replace it.
FAQ
What is the OpenAI Decisions API?
It's a preview service that uses Luna to answer questions you define, choosing from a finite set of possible answers. OpenAI names classification, routing and agent action selection as intended uses.
How much does the OpenAI Decisions API cost?
A separate price remains unconfirmed in the sources reviewed. Regular Luna standard short-context rates are $0.10 per million input tokens and $0.50 per million output tokens; those aren't a confirmed Decisions API tariff.
Can I use Decisions API today?
OpenAI announced limited preview access, with broader release planned soon. As of September 30, 2026, access for every account and a public integration reference remain unconfirmed.
Does Decisions API accept images?
Yes. The official recap says developers can provide text or image context. It does not publish an image decision benchmark.
Does a closed answer set guarantee the right answer?
No. An answer can fit your application's interface and still be the wrong choice. Test routing accuracy separately from output format.