OpenAI’s Decisions API exits beta at 400 questions a call

OpenAI on October 22 made its Decisions API generally available, just over two weeks after the public beta opened to all developers on October 6. A single request can now carry up to 400 questions, double the beta limit of 200.

The API runs on GPT-6 Luna and answers only questions with bounded answers: a probability, one option from a list you supply, or a score on a rubric. In its announcement on the OpenAI blog, the company says it returns these answers up to 10x faster than GPT-6 Luna does through the Responses API, for inputs that can be text, images or structured data. At the DevDay preview on September 29, OpenAI described that gap as 150 milliseconds against 1.6 seconds for Luna. OpenAI’s pitch is that each of these small calls is cheap on its own, but at scale their latency and cost add up across a workflow.

How a request is built

The developer guide splits a request into three parts. model currently accepts only gpt-6-luna. input holds the shared evidence, either as a text string or as an ordered array of messages, tool calls and tool outputs. questions lists what you want decided, each question with its type, its instructions and any allowed choices or score levels. The response comes back as an answers array, and each answer echoes the unique name you gave its question, so an application can match results to questions without relying on their order.

The three question types return different things:

• predicate: a probability from 0 to 1 that a condition is true, such as whether a product shows visible damage.
• choice: one of your predefined values, such as whether an agent should continue, retry or ask for clarification, along with probabilities and a confidence figure.
• score: the probability-weighted average of the indices of ordered rubric levels, such as damage severity, so the result can fall between two levels.

Choice fits unordered categories like support departments, and score fits ordered ones like severity. Because both return probabilities across the options, OpenAI advises picking thresholds for filtering, routing or human review from labeled examples taken from your own application. The guide sends work that needs a custom JSON object, such as extracted fields or a written explanation, to Structured Outputs in the Responses API, and tool calls with arguments to function calling.

The bill is input only

Decisions costs $0.10 per million input tokens and $0.01 per million cached input tokens, and there is no charge for output tokens. Cached context therefore costs a tenth of the uncached rate, which matters for applications that resend the same instructions or reference material with every decision. Writes to the 30-minute and 12-hour caches have their own rates in OpenAI’s pricing guide.

The uncached rate is unchanged from the beta, when $0.10 per million input tokens came with no separate charge for output, cache reads or cache writes. Prompt caching for reused context is one of the additions OpenAI lists since the beta, along with the $0.01 rate.

What the beta could not do

During the beta, images had to be sent inline as base64 data URLs; hosted links and uploaded file IDs were not accepted. The guide says the beta endpoint took only user messages with text and inline image data, with no audio, files, function calls, function-call outputs, non-user roles or item references, and capped a request at 128 image parts.

The general release lifts much of that. The guide now lists these capabilities as added since the beta:

• hosted image inputs from public HTTP or HTTPS URLs;
• conversation history as input, including messages, function calls, custom tool calls and their outputs;
• native JSON input;
• images inside question instructions;
• organization usage reporting with token counts and request counts;
• Private Link for sending requests over a private connection.

On the infrastructure side, inference residency is available in the US and EU, Zero Data Retention is offered to eligible customers, and OpenAI says it has added capacity in several regions in Asia to cut latency there.

Decisions inside a voice call

The other headline addition is a native integration with GPT-Live, OpenAI’s real-time voice product. A Decisions configuration goes into session.triggers of an existing Live session; as transcript updates arrive, Live emits a decision.event, and the application reads the result and acts on it. OpenAI’s examples include a support agent deciding mid-conversation whether to ask a clarifying question, route a request or escalate, and an avatar that changes its facial expression while the user is still speaking, answering a line with a wink or a smile.

The public demo lets visitors try this against a palette of faces. Its suggested prompt: “I rehearsed my audition for my cat. She walked out halfway through.”

Who is using it

OpenAI’s internal deployments are its main examples. The dots team uses the API to cut response times and make the product more interactive. The Personal Finance team categorizes transaction descriptions with it. The Communications team classifies press coverage by theme and scores whether a piece reinforces or challenges key narratives, to flag what needs a closer look. On the customer side, OpenAI names two uses without naming the customers: attributing AI costs accurately and making language-learning apps more interactive.

The API is available now through a dedicated Decisions endpoint. OpenAI’s suggested first step is to pick one recurring decision your application makes often, define the question, the allowed answers and the context needed to tell them apart, and test it on real examples in the Decisions Playground before wiring it into production.