OpenAI Decisions API Explained: Fast Classification and Routing With GPT-6 Luna, Pricing and Use Cases

OpenAI's Decisions API answers questions with a fixed set of possible answers about ten times faster than a normal model call. How predicate, choice and score questions work, what it costs, where it fits in agent systems, and how it compares with TypeSafe's Jev.

PUBLISHED // UPDATED
DURATION // 06 MIN READ
Laptop showing a short multiple-choice list next to a stopwatch, office daylight, no logos or brand marks
FIG.01 // VISUAL DOCUMENTATION Laptop showing a short multiple-choice list next to a stopwatch, office daylight, no logos or brand marks

Many decisions inside software do not need a model to write anything. Is this ticket about billing? Does this photo show damage? Which agent should handle the next step? OpenAI’s Decisions API, announced at DevDay 2026, is built for exactly these questions: you supply the evidence and a fixed set of possible answers, and it returns a typed answer with probabilities instead of generated text. This guide explains how it works, what it costs, where it fits, and how to adopt it safely.

What the Decisions API is

According to InfoQ’s DevDay recap, OpenAI introduced the Decisions API in limited preview at DevDay on September 29, 2026, alongside GPT-6.1 Sol, computer use in the Agents API and cloud environments for Codex. It uses the smaller GPT-6 Luna model to select from a predefined set of answers based on text or image context, and OpenAI positions it for classification, request routing and choosing an agent’s next action.

Startup Fortune reported that it returns a probability-scored choice in about 150 milliseconds, compared with roughly 1.6 seconds for a standard Luna call. OpenAI’s Decisions documentation now describes the API as generally available and “about 10x faster than the Responses API”.

Three question types

Each request contains the model (currently only gpt-6-luna), shared input evidence, and one or more questions. The documentation defines three question types:

TypeUse it toReturns
predicateCheck whether a condition is true, such as visible damage in a photoA probability from 0 to 1
choicePick one option from a list, such as a departmentThe chosen value, probabilities for each option and a confidence figure
scoreRate against ordered levels, such as issue severityA probability-weighted score between levels, plus per-level probabilities

For example, a support ticket saying “I was charged twice for my order” can be sent with a choice question listing billing, technical, shipping and other. The response names a department and gives probabilities for each option.

Inputs can be text, images, JSON objects, or a conversation history including tool calls and their outputs. Since general availability, a single request can carry up to 400 questions, up from 200 during the beta, and question instructions can include their own images, which is useful for comparing a candidate image against a shared reference.

What it costs

OpenAI’s documentation lists uncached input at $0.10 per million tokens for gpt-6-luna on the Decisions endpoint, and output tokens are not charged. Prompt caching discounts repeated input once the shared prefix reaches at least 1,024 tokens, so placing a long policy document or reference image in the shared input and changing only the questions keeps costs down. Regional processing and long-context multipliers can apply.

Because a request with several questions counts as one request, batching related checks (for example, “is it damaged?” and “which product category?”) is both cheaper and faster than separate calls.

A worked example: returns inspection

Consider an online retailer that receives thousands of return photos a day. A single Decisions request can include the customer’s photo and order record as shared input, then ask three questions at once: a predicate asking whether the product shows visible damage such as a crack, tear or dent (ignoring packaging), a choice selecting the product category, and a score rating how severe any damage is on a three-level scale. The retailer’s own code then applies rules: low damage probability goes to automatic restocking, high probability with a high severity score goes to a claims queue, and anything with low confidence or an “other” category goes to a person. Each step remains auditable because the probabilities are stored alongside the decision.

Where it fits

The Decisions API is not a replacement for a chat model. It does not write the reply to the customer, draft code or explain its reasoning. OpenAI’s guidance is to use Structured Outputs or function calling when you need generated content or tool arguments, and Decisions when you need one of its three answer types. Good fits include:

  • Ticket and email routing, choosing a queue or team.
  • Content moderation and policy checks, returning a probability that content breaks a rule.
  • Image inspection, such as damage checks in returns or insurance claims.
  • Agent orchestration, deciding which sub-agent acts next or whether an output should be trusted.
  • Prioritisation, scoring severity or urgency on a defined scale.

For agent systems, the speed matters. Monitoring every action with a full frontier model is slow and expensive; a fast typed check makes it practical to evaluate many more steps. Your application still executes whatever action the answer selects, which keeps control in your code.

Competition: TypeSafe’s Jev

The Decisions API arrived two weeks after TypeSafe AI, founded by former OpenAI researcher Diogo Almeida, emerged from stealth with Jev, a model designed only to answer typed questions with calibrated confidence scores. Startup Fortune notes the similarity and, citing TechCrunch, reports TypeSafe’s claim that monitoring with Jev costs about $2.94 versus roughly $372 with a frontier LLM for the same job. These are vendor-reported comparisons, but they show the direction of the market: small, specialised decision models for the high-volume checks inside software.

How to adopt it safely

  1. Write questions around observable criteria. The documentation recommends separating concerns into different questions, giving choices distinct meanings and defining score levels clearly.
  2. Always include a fallback option such as “other”, and send those cases to a review queue.
  3. Set thresholds from labelled examples. Use your own historical data to decide what probability triggers an action, weighing the cost of false positives and false negatives.
  4. Keep humans on high-impact decisions. Use the API to route and prioritise, not to make irreversible decisions such as refunds or account closures without review.
  5. Monitor usage and drift. OpenAI provides an organisation usage endpoint; also track how often answers are overridden by people.
  6. Check data controls. The documentation states that Zero Data Retention and HIPAA use are supported for eligible customers, with regional processing in the US and Europe.

For related tooling, see our coverage of Codex cloud environments, Claude Code’s parallel agents, and security practices for AI coding agent plugins.

Our analysis

The Decisions API addresses an unglamorous but common need: making many small, structured decisions quickly and cheaply. Its typed answers and probabilities fit naturally into existing software, and free output tokens make it inexpensive for high-volume classification. The main work for adopters is not integration but calibration: defining clear questions and fallback options, and setting thresholds based on real data before letting answers drive automated actions.