OpenAI Decisions API: What It Is and How to Use It

The OpenAI Decisions API is a new endpoint, announced at DevDay on September 29, 2026, that points GPT-6 Luna at a question you define and a fixed list of answers you supply. It returns one of those answers instead of free-form text. You send text or images as context, and you get a choice back.

It is also very new. As of September 30, 2026, it is in limited preview, OpenAI has not published a price or request syntax, and the only hands-on numbers so far come from early tests reported by Every. This guide separates what OpenAI has confirmed from what is only reported, and shows where a training team could use it.

The Decisions API is one of more than 20 launches covered in our OpenAI DevDay 2026 announcements roundup. If Luna is unfamiliar, start with the GPT-6 Sol vs Luna vs Astra comparison.

What is the OpenAI Decisions API?

The OpenAI Decisions API lets a developer ask a question, supply a closed list of possible answers plus some context, and get one answer back. OpenAI describes it as focusing Luna’s intelligence on user-defined questions with finite pre-defined answers. Context can be text or images. It launched as a limited preview.

Luna is OpenAI’s cheapest model, listed at $0.10 per million input tokens and $0.50 per million output tokens. In its DevDay 2026 recap, OpenAI names three uses: classifying content, routing requests and choosing an agent’s next action.

The Decoder frames it as OpenAI’s entry into “System One” models: fast, specialised models that sit beside a stronger model that plans the work. The New Stack describes it as sitting between two familiar options: prompting a chat model, and training your own classifier.

How is the OpenAI Decisions API different from a normal chat completion or structured outputs?

A chat completion generates open-ended text that you then parse and validate. The Decisions API limits the output space itself, so the model can only pick from the answers you list. That removes one class of error, such as an invented label, but it cannot guarantee the chosen answer is correct.

You can already approximate a closed answer set today by asking a chat model for JSON with an enumerated field. The Decisions API appears to package that pattern as a dedicated surface built for speed. FourWeekMBA’s analysis makes the same point: the difference is focus on high-volume classification and routing, not a new kind of model.

OpenAI has not published a technical comparison with structured outputs, so treat the advantage as unproven. Developer reaction summarised by daily.dev is mixed, and some critics call it a Luna wrapper.

The closest rival is Jev from TypeSafe, a decision model that emerged from stealth just before DevDay. Every reports that Jev handles text only, while the Decisions API also accepts images. For the wider idea of fast decision models sitting beside language models, see our explainer on Jev vs LLM: System One vs System Two.

How fast is the Decisions API?

OpenAI’s reported figure is about 150 milliseconds per decision, roughly ten times faster than Luna through the regular API at 1.6 seconds, according to The Decoder. Every measured a typical 230 milliseconds in its own early tests. Neither number is an independent benchmark, and both are early.

The gap between 150 and 230 ms is plausible given different tasks, inputs and network paths. OrcaRouter notes that only a vendor-reported median exists, with no p95 or p99 figures and no regional data.

Speed matters when a decision sits in the middle of a live interaction: routing a message while the user waits, or picking the next click for an agent. For overnight batch tagging, a slower call costs you nothing.

How much does the Decisions API cost?

OpenAI has not published a price for the Decisions API. A dev.to roundup reports it will be billed at Luna’s standard rate of $0.10 per million input tokens and $0.50 per million output tokens, while Every says pricing has not been announced. Use Luna’s rate as a planning assumption only.

Here is the arithmetic if the Luna rate applies. Suppose each decision sends 500 input tokens of context and returns about 10 output tokens. One million decisions would use 500 million input tokens, about $50, plus 10 million output tokens, about $5. That is roughly $55 for a million decisions.

Images will change the sum, because they consume more tokens than a short text snippet. Treat this as an illustration of scale, not a quote.

Is the Decisions API available yet?

As of September 30, 2026, the Decisions API is in limited preview, and OpenAI says a broader release will come in the coming days. We could not find a public application route, endpoint reference or SDK example, so most teams cannot build against it yet.

Two open-source projects confirm the gap. Maintainers of an LLM client library noted that public technical documentation had not been found, and deferred support until OpenAI publishes it. That is why this article describes the API in words and not with copy-paste code.

Several details remain unconfirmed as of today:

• How many candidate answers one request can hold.
• Whether it returns a confidence score. The New Stack reports scores, but SmartScope lists this as unconfirmed, and OpenAI’s own wording does not mention them.
• Whether you can tune it on your own data.
• Regional availability and data-handling terms.

Watch the OpenAI DevDay 2026 recap on this site for updates once the broad release lands.

How accurate was the Decisions API in early hands-on tests?

Early results look promising but thin. In Every’s testing, senior editor Jack Cheng scored the Decisions API at 76 of 78 correct steps against Jev’s 73, and Cora’s Kieran Klaassen found the two effectively tied on conversation classification. These are small, informal tests, and OpenAI has published no benchmarks.

The speed results point in opposite directions, which is the useful lesson. Performance depended on the task, so a vendor’s headline number will not tell you how it behaves on your tickets, your content or your learners’ answers. Every’s own framing is that these are early tests.

What can developers use the OpenAI Decisions API for?

OpenAI names three uses: content classification, request routing and choosing an agent’s next action. Any task where the correct output is one item from a known list fits. Image input widens that to screenshots, photos and scanned forms. Open-ended writing and multi-step reasoning do not fit.

Concrete examples from the launch coverage and Every’s testing include:

• Content classification: tagging a post or upload as safe, sensitive or off-topic.
• Request routing: sending an incoming message to the right team or queue.
• Agent action selection: deciding which on-screen button an agent should click next.
• Inbox triage: deciding whether an email needs a reply.

The agent case pairs naturally with the computer-use tooling described in our post on the OpenAI Agents API with computer use. A plausible pattern is a stronger model such as GPT-6.1 Sol handling the plan, with a fast decision call handling the many small checks along the way. That is our reading of the System One idea, not an OpenAI-documented design.

If you build software, our list of AI tools for developers covers the surrounding toolkit.

How could L&D teams use the Decisions API?

L&D teams could use a fixed-answer model wherever people already sort things into known categories: support tickets, content tags and short quiz answers. These are possibilities, not tested deployments. The API is in preview, and no LMS vendor has announced support. Keep a human on any decision that touches a learner’s record.

Could it route learner support tickets?

Yes, in principle. A training operations team could define answers such as login and access, course content, completion or certificate record, technical fault and billing, then let the model assign each incoming ticket. A fast call means the routing happens before the learner sees a confirmation page.

Measure it against your current manual triage first. Misrouted tickets that involve completion records can create audit problems.

Could it tag content to a skills taxonomy?

Possibly, with a limit. A team could tag microlearning, SCORM packages or video transcripts to a skills framework by giving the model the content and the list of skills. The unknown is how many candidate answers one request supports, and many taxonomies run to hundreds of entries.

A workaround is two passes: pick a skill family first, then a skill within it. Instructional designers should still review tags before they drive recommendations in an LXP.

Could it triage compliance quiz answers?

Perhaps as a first pass only. For short free-text answers in compliance training, the model could sort responses into correct, partially correct, off-topic, or needs review, so SMEs spend their time on the uncertain ones. That saves review effort at Kirkpatrick Level 2, which measures learning.

It should never be the final judge of a pass or fail on regulated training. Also check your data-processing terms before sending learner responses to any external model.

Buyers comparing platforms can ask vendors whether their roadmap includes closed-answer classification like this. Our guide to AI-powered LMS platforms is a starting point for that conversation.

When should you not use the Decisions API?

Skip it when the answer is not a choice from a known list, when a wrong answer is costly and unreviewed, or when you need published pricing and service terms today. A closed answer set cannot explain, summarise, coach or draft, and it cannot handle a situation you failed to list.

Avoid or delay it in these cases:

• Open-ended work: course drafts, learner feedback, explanations and summaries need a normal chat model.
• High-stakes final decisions: certification, disciplinary and compliance sign-off calls belong to people.
• Very large label sets: the candidate limit is unpublished, so a taxonomy with hundreds of entries is a risk.
• Tiny volumes: if you sort a few dozen items a week, a normal model call already works.
• Production commitments today: a preview has no confirmed price, syntax or service terms.

Remember the limits of the evidence, too. The one clear advantage reported so far is image input, and the one clear disadvantage is that nothing is documented.

How do you get ready for the Decisions API before broad release?

You can prepare now without API access. Write your question and answer set, collect labelled real examples, run the same task on a cheap chat model, and record accuracy, speed and cost. When the Decisions API opens, you repeat the same test and compare.

Step 1: Write the question and the closed answer set

Make each answer distinct and cover the edge cases, including an “unsure” option. Vague labels are the most common reason classifiers disappoint.

Step 2: Build a labelled test set

Collect a few hundred real examples, such as past tickets or short answers, and have an SME label them. Keep a share aside that you never tune against.

Step 3: Set a baseline with what you can use today

Run the task on a small chat model with a JSON output that only allows your answers. Record accuracy, median and slowest response times, and cost per thousand items.

Step 4: Decide the review lane and the data rules

Write down which answers go to a human and what personal data may leave your systems. Do this before the API opens, not after.

This conceptual sketch shows the pieces you should have ready. It is not OpenAI syntax, because none has been published.

Conceptual sketch only. Not real API syntax.

Question:  Which team should handle this learner ticket?
Answers:   login_and_access | course_content | completion_record | technical_fault | billing | needs_human_review
Context:   the ticket text (or a screenshot)
Returns:   one answer from the list

Conclusion

Pick one workflow this week and prepare it: a support inbox, a content-tagging job or a quiz-review queue. Write the answer list, label a few hundred real examples and record your baseline. That work is useful whatever OpenAI publishes, and it means you can judge the Decisions API on your own data instead of on launch-day claims.

When broad access opens, rerun the same test and compare accuracy, speed and cost. Adopt it only if it clearly beats your baseline, and keep a human review lane for anything that affects a learner or a compliance record.

For the wider picture of what shipped alongside it, read our OpenAI DevDay 2026 recap and check back here as OpenAI publishes pricing and documentation.