Decisions API Out of Beta: The AI That Sorts Tickets in Milliseconds
The Decisions API is out of beta as of October 22, 2026: up to 400 questions per request and a thousand tickets sorted for about 15 cents.
The Decisions API is out of beta: since October 22, 2026, OpenAI's endpoint is generally available. It doesn't write answers; it answers closed questions about a text, an image, or a JSON and returns probabilities. It fits ticket triage, call auditing, and decisions about photos, and in the video's example sorting a thousand support tickets costs about fifteen cents.
What changed now that the Decisions API is out of beta
Most coverage will frame it as "OpenAI launched another model," but the news is a new endpoint. You call it with a POST to /v1/decisions, and the only model it accepts today is gpt-6-luna.
What's different from the October 6 beta:
- Up from 200 to 400 questions per request.
- You can now put images inside the questions.
- The material shared between questions is cached, which makes the rest cheaper.
According to OpenAI, a decision that used to take one to three seconds now takes roughly 100 to 180 milliseconds. That figure is published by OpenAI and, as far as we know, there is no independent latency benchmark. The problem it targets is old: a helpdesk vendor estimates that almost one in four tickets lands in the wrong queue. That's a vendor number, so take it only as an order of magnitude.
How it works: predicate, choice, and score
You hand over the material and a list of questions, and each question is one of three types:
- Predicate: a true-or-false statement; it returns a probability from zero to one.
- Choice: picks one of the options you defined, with each option's probability and a confidence level.
- Score: a scale of two to ten levels, such as low, medium, and high urgency; it returns a number that can fall between two levels.
The piece almost nobody mentions: the questions don't depend on each other. They are all answered over the same material, which is why 400 fit in one call and why caching works.
One ticket, start to finish
The video's example is an online store: the customer writes "you charged me twice, please refund," and the order JSON shows two charges of $49. You open the Playground, paste both, and write three questions: a predicate (is there a duplicate charge backed by the order?), a choice (billing, shipping, technical, or other), and an urgency score.
In the documentation's example, billing comes back at 95% probability with a confidence of 93. Two practical details: if you forget the "other" option, the API forces you to pick a category, and the result contains only answers; it executes nothing. Your code decides what to do with them.
The math: tickets, tokens, and dollars
The Decisions API charges 10 cents per million input tokens, and output isn't charged. With the video's assumption, a ticket with its fifteen questions is about 1,500 tokens:
- A thousand tickets: about 15 cents.
- Ten thousand tickets a month: about $1.50.
- Manual triage at 45 seconds per ticket and $15 an hour: 125 hours, $1,875. That is a hypothetical example, not published data.
Keep the comparison fair: against the same Luna through the Responses API, which does charge for output, the price saving is only about a quarter. The big deal isn't price, it's speed.
Three uses for your business
These are WAiBOT's analysis, not cases published by OpenAI.
- Ticket triage: the message and the order JSON go in, and in under a second the ticket sits in the right queue with a priority.
- Call auditing: a clinic with a list of 40 questions about a transcript makes one request instead of 40, and can review every call, not a sample. Use score for quality, because it gives nuance.
- Decisions about photos: a customer sends a picture of a damaged package and the question carries the image inside. The answer is a probability and you set the threshold: above 95 you approve the refund, between 50 and 95 a person reviews it.
To see how this endpoint connects to live voice, read the full breakdown of GPT-Live and Decisions. For the price and limits during the beta, there's the Decisions API summary.
Who it's not for, and what breaks
It's not for you if you need it to explain why or to write a reply: it returns answers, not text. Nor if your input is files or audio, because it only accepts text, images, and JSON. And if you have few cases and nobody minds waiting three seconds, you don't need the speed.
If you already have millions of tickets with stable labels, your own classifier runs locally, nearly free, and without depending on anyone: in that case, don't migrate. If your categories change every month or you have no labeled data, this API saves you the training.
What breaks in practice:
- Choice spreads probability across your options: if the ticket doesn't fit and you didn't add "other," it still gives you a category with a confident look.
- Confidence isn't certainty: in the documentation, a score of 1.1 comes with 55% confidence.
- Dependent decisions need two requests, because questions don't see each other's answers.
- The guide doesn't publish rate limits, so test with your volume before promising anything.
How to apply it in your business?
The video's five-step template:
- Write your decisions as closed questions: yes or no is a predicate, a label is a choice, a scale is a score.
- Add an "other" option to every choice.
- Gather 200 to 500 labeled cases from your operation.
- Run the API on them and set thresholds by what each error costs: a false refund doesn't cost the same as an ignored complaint.
- Measure latency from your region and leave a gray zone for a person.
The warning that avoids the costliest mistake: the API only answers, and your application is the one that acts. Never wire an automatic refund to a probability without a threshold.
Frequently asked questions
What is OpenAI's Decisions API?
It's an endpoint that answers closed questions about a text, an image, or a JSON and returns probabilities, not written text. Today it accepts only the gpt-6-luna model.
How much does the Decisions API cost?
It charges 10 cents per million input tokens and output isn't charged. With the video's assumption, a thousand tickets come to about 15 cents.
What question types does it accept?
Three: predicate (true or false with a probability), choice (one of your options, with confidence), and score (a scale of two to ten levels).
Is it really ten times faster?
That's what OpenAI claims: from one to three seconds down to roughly 100 to 180 milliseconds. There's no independent latency benchmark, so measure it with your own tickets.
Conclusion
That the Decisions API is out of beta isn't a model story, it's an operations story: the real question isn't whether AI classifies well, but how much of your work is already a closed decision with few options that someone makes by hand every day. Try it on 200 to 500 labeled tickets before you migrate, and tell us in the comments which decision you repeat most in your business.