Not every AI task needs a model that writes. OpenAI’s new Decisions API answers fixed questions with typed results, around ten times faster than its general-purpose API, and it could quietly reshape how products route, triage and check their work.
What it is
The Decisions API was one of the quieter launches at OpenAI DevDay 2026, and its guide is now live. Instead of generating free text, it reads the evidence you give it, text, images or both, and returns typed answers to questions you define: a probability, a choice from a fixed list, or a score on an ordered scale.
OpenAI says it returns those answers about ten times faster than its Responses API. It runs on a dedicated endpoint, POST /v1/decisions, with gpt-6-luna currently the only model available. It’s in public beta, with general availability expected in the coming weeks.
How it works
Each request has three parts: the model, the input (the shared evidence) and a list of questions. Every question has a name, instructions and, depending on its type, the answers it’s allowed to give. There are three types:
| Question type | What it answers | What comes back |
|---|---|---|
| Predicate | Is something true? For example, does this product show visible damage? | A probability from 0 to 1 |
| Choice | Which one of a fixed set? For example, which department should handle this complaint? | The chosen option, a probability for every option and a confidence |
| Score | Where does it sit on an ordered scale? For example, how severe is this issue? | A score across the levels, with probabilities and a confidence |
Several independent questions can share one request, so a single support message can be routed, scored for severity and checked for a refund request at once. The answers come back in the same order as the questions, ready for your code to act on without any parsing.
Why it matters
Speed. Answers arrive around ten times faster than a general-purpose model call. That makes AI practical in places it was too slow for: inside a checkout, at the front of a support queue, or at every step of an agent.
Cost. Pricing is $0.10 per million input tokens, and you only pay for input. There are no output-token or caching charges.
Reliability. Answers are constrained to the options you define, so there are no invented categories to catch. Every answer carries probabilities, so your software can tell a confident call from a close one.
Compliance. The API supports Zero Data Retention and HIPAA use for eligible customers, with data residency in the United States and Europe. That opens it up to healthcare, finance and the public sector.
Where we’d use it
OpenAI’s own examples point at the obvious wins, and they map closely onto work we see every week:
- Routing. Sending complaints, emails and enquiries to the right team the moment they arrive.
- Inspection. Checking a photo for damage before a return or claim is approved, because the API reads images as well as text.
- Prioritisation. Scoring tickets and incidents by severity so the urgent ones surface first.
- Classification. Tagging content, documents and feedback at scale, the kind of work we automated for Inpulse.
- Agent guardrails. Deciding an agent’s next step, or whether a proposed action needs a person to approve it.
A pattern, not just a product
The Decisions API arrives days after TypeSafe AI launched Jev, the first “System One” model, built on the same idea: fast, bounded decisions with calibrated probabilities, rather than another model that writes. The two differ in the details:
| OpenAI Decisions API | TypeSafe Jev | |
|---|---|---|
| Inputs | Text and images | Text, JSON and lists of strings |
| Question types | Predicate, choice, score | Noul, choice, score |
| Input price | $0.10 per million tokens | $0.042 per million tokens |
| Output price | Free | Free |
| Status | Public beta | Early access |
When OpenAI and a specialist start-up ship the same pattern within days of each other, it’s a fair signal of where AI products are heading: a fast decision layer for the many small calls, with larger reasoning models kept for the few hard ones.
Getting it right
OpenAI’s guidance lines up with how we design these systems:
- Ask about observable facts. “Does the photo show a crack, tear or dent?” works better than “Is this product acceptable?”
- One concern per question. Split compound judgements into separate questions and combine them in code.
- Make choices distinct, and include an “other”. Real inputs don’t always fit your categories.
- Set thresholds from labelled examples. Decide when to automate and when to escalate based on what a wrong answer actually costs you.
- Keep dependent decisions in separate requests. If one answer changes the next question, ask it in a second call.
And know where it stops. If you need the model to produce an object in your own format, or to call a tool, OpenAI points to Structured Outputs and function calling in the Responses API instead.
If you’re looking at where fast decisions could take cost and waiting time out of your product or operations, we’d be glad to help you find the first one worth automating.
