OpenAI Decisions API GA: which classifier calls to move

OpenAI's Decisions API is now generally available with gpt-6-luna. It answers fixed questions about text, images, JSON or a conversation with a probability, a choice or a rubric score, and never writes prose. Teams should move routing, triage and grading calls that parse a model's text today, and keep extraction and tool calling on Responses.

What was released

General availability of the Decisions API was announced by OpenAI on 22 October 2026 in its API changelog and in the post Build more responsive apps with the Decisions API. It follows a public beta that opened on 6 October. Requests go to POST /v1/decisions, and gpt-6-luna is the only supported model.

The Decisions guide describes three question types. A predicate returns the probability that a condition is true. A choice picks one value from options you supply and returns the probability of each. A score rates the input against 2 to 10 ordered levels and returns a probability-weighted average, so a result can fall between two levels. Choice and score answers also carry a separate confidence field, and any answer can come back as a refusal.

What changed since the beta

The guide lists these additions at general availability:

• More questions per request: up to 400, up from 200 in the beta.
• Prompt caching: shared input gets an implicit cache breakpoint by default, so existing requests can benefit without code changes. The reusable prefix must be at least 1,024 tokens, and question text does not count towards it. prompt_cache_key partitions reuse, and explicit breakpoints give you control of the boundary.
• JSON input: an input_json content part passes structured records without turning them into a string. Keys such as role inside the data are treated as data, not as messages.
• Images in questions: each question can carry its own image to compare against shared evidence, and images can now be public HTTP or HTTPS URLs as well as base64. file_id inputs are not supported.
• Conversation history: input can hold messages plus function and custom tool calls and their outputs, so you can judge an agent's turn in context. Files and audio are not accepted.
• Usage reporting: GET /v1/organization/usage/decisions reports tokens and requests, where a request with many questions counts once.
• Voice and networking: native delegation from GPT-Live to Decisions, and Private Link support.

On pricing, the Decisions guide's pricing section bills uncached input at the gpt-6-luna input rate and does not charge for output tokens. Cache reads and writes follow the standard gpt-6-luna caching rates. Zero Data Retention and HIPAA use are supported for eligible customers, and regional processing is available in the United States and Europe.

Which calls to move off the Responses API

CodeDTX's view: most agent stacks have a handful of small model calls whose only job is to pick a branch. A router that asks a chat model "which department?" and then parses the reply, a guardrail that asks "is this request in scope?", a grader that asks for a severity from one to three. These are the calls to move first, because the Decisions API returns the typed answer directly, there is no output to bill, and there is no string to parse or retry when the format drifts.

Routing and triage. A choice question with a fallback option such as other replaces a prompt plus a parser. The guide recommends that fallback so inputs outside your categories land in a review queue instead of being forced into the nearest bucket.

Pre-checks on agent turns. Because input now accepts tool calls and outputs, you can ask predicates about what an agent just did ("did the tool output confirm the refund?") before your code acts on it. The Decisions API only answers; your application still runs the action, which keeps the approval logic in code you own.

Batch grading. Up to 400 questions against one shared input, with the shared part cached, suits rubric checks over a long document or a full transcript. It is also a cheap way to run the checks behind AI agent evals on every release.

Leave these on Responses. Anything that must produce an object in your own schema, such as extracted fields or a written explanation, belongs with Structured Outputs, and anything that requests a tool call with arguments belongs with function calling. The guide draws the same line. Questions that depend on an earlier answer also need separate requests, so a chain of dependent checks will not collapse into one call.

What to set up before you switch

Thresholds, owned by someone. A probability is not a decision until your code compares it with a threshold. The guide says to set thresholds from labelled examples and the cost of false positives and false negatives. Write down who owns each one and when it is reviewed, as you would for any confidence score that sends work to a human.

A labelled set from today's traffic. Before you replace a working classifier prompt, run both over the same few hundred labelled cases and compare. The change in latency is easy to see; a change in where errors fall is not.

Cache-friendly request shapes. Put the stable material, such as a policy or reference document, at the start of input and keep it byte-identical, and put what varies into the questions. Check cached_tokens and cache_write_tokens in the usage block to confirm the cache is being used, because cache writes are charged.

Refusal handling. Every code sample in the guide branches on a refusal answer type. Route refusals to a person or a safe default rather than treating them as a no.

One model, one vendor. Only gpt-6-luna is supported today. If you already run Perplexity's Decisions API, note that the two share a name and a general idea but run on different endpoints, models and API keys, so check the request and answer formats before reusing code. Keep the decision call behind your own interface so you can switch provider or fall back to a prompt if the endpoint is unavailable.

When not to switch

Stay where you are if a classifier already runs on a small self-hosted model that meets your accuracy and data rules, if you need the model's reasoning written down for an audit trail, or if your inputs include files or audio, which the endpoint does not accept. Wait if your contracts require data residency in a region outside the United States and Europe. Move when you have several parse-and-retry classifier calls on a hot path, when grading costs are driven by output tokens, or when a voice agent needs to choose an action while the user is still speaking.

Frequently asked questions

What is the OpenAI Decisions API?

It is an OpenAI endpoint, POST /v1/decisions, that answers fixed questions about text, images, JSON or a conversation with typed results instead of generated text. A predicate returns a probability that something is true, a choice picks one of your supplied options, and a score rates the input against ordered levels. It became generally available on 22 October 2026 and runs only on gpt-6-luna.

What changed between the beta and general availability?

At general availability OpenAI added prompt caching on shared input, a JSON input type, per-question images, public image URLs, conversation history with tool calls and outputs, an organisation usage endpoint, native GPT-Live integration and Private Link. The limit rose to 400 questions per request, up from 200 in the beta. Existing requests can use caching without changes because a cache breakpoint is placed at the end of shared input by default.

Should I replace my classifier prompts with the Decisions API?

Replace the ones whose output you parse into a label, a yes or no, or a level, and test each against labelled examples first. Keep prompts that must produce structured fields, explanations or tool calls on the Responses API. Leave a working self-hosted classifier in place unless the move saves real latency or cost. In every case, decide the thresholds the probabilities feed into and who owns them.

How is the Decisions API priced?

According to OpenAI's guide, uncached input on gpt-6-luna is billed at a per-token rate and output tokens are not charged. Prompt cache hits get discounted input pricing at the standard gpt-6-luna caching rates, and cache writes are charged. Regional processing premiums and long-context multipliers apply. Check the pricing section of the Decisions guide before you estimate a migration, because rates for other gpt-6-luna endpoints differ.

Is the OpenAI Decisions API the same as Perplexity's?

No. Both return probabilities rather than text and both are called the Decisions API, but they are separate products from separate companies, with different endpoints, models and API keys. Check each vendor's request and answer formats before reusing code written for the other. If you use both, put the call behind your own interface so your routing and grading logic does not depend on either vendor's format.