OpenAI's Decisions API evaluates text and images to return typed answers: the probability that a condition is true, a choice from defined options, or a score against an ordered rubric. It is available in public beta through POST /v1/decisions, with GPT-6 Luna as its supported model.
OpenAI introduced the API at DevDay on September 29, 2026. Consider an application that receives a customer message and needs to assign it to a team. Before anyone writes a reply, the application needs a narrower answer: which team should handle this request? Decisions API gives that kind of choice its own interface.
Copy link to headingHow does a question with predefined answers work?
You define the decision your application needs and the answers it can use. The model evaluates the supplied context against that question. Your application then interprets the selected answer according to its own rules.
For a support form, a proposed routing question might be, "Which team should handle this request first?" The possible answers could be:
Messages that mention an invoice don't always belong in Billing. If the customer says they cannot sign in to download it, the immediate problem is account access. The question and category definitions should express that priority so the model can distinguish the customer's eventual goal from the first step needed to help them.
These category definitions are an application design example. Test the routing behavior on reviewed messages before using the answer to assign work.
Choices are one of three supported question types:
Score levels start at zero and run from lowest to highest. With levels for no coverage, partial coverage, and complete coverage, a document-relevance rubric produces a score between 0 and 2. Because the score averages the level indices using their probabilities, it can fall between levels. The probability that a passage answers a query and the extent of its coverage answer different questions.
Copy link to headingHow do you send a decision request?
The request has a model, shared input, and a questions array. Give each question a unique name so your code can identify its answer. The response contains an answers array in question order and echoes each question's name.
This example checks whether a passage contains a concrete step for rotating an API key. Set OPENAI_API_KEY in your server environment before running the request:
curl --fail-with-body https://api.openai.com/v1/decisions \ -H "Authorization: Bearer $OPENAI_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "gpt-6-luna", "input": "Query: How do I rotate an API key? Passage: Create a replacement key, update the services that use the old key, then revoke the old key after checking those services.", "questions": [{ "type": "predicate", "name": "answers_query", "instructions": "Does the passage provide at least one concrete step for rotating an API key? Mentioning API keys without a rotation step does not count." }] }'For a successful predicate answer, read probability from the entry named answers_query. The API reference also permits an answer with type: "refusal". Check the answer type before reading its numeric fields, and send refusals or failed requests through your application's review or error path.
Independent questions can share one request. For example, you could check passage relevance and rate coverage against the same query. When a later question depends on an earlier answer, use separate requests and let application code decide whether the later question is needed.
Copy link to headingWhat can you use OpenAI’s Decisions API for?
The application defines the condition, allowed choices, or rubric before making a request. Use the resulting answers to choose a workflow branch, classify content, or prioritize items for review.
For example, a document intake system could classify an incoming note as a product guide, an incident report, or an item needing review. The application would use the answer to choose the next processing step. It would still need a separate extraction step if that workflow also requires names or dates from the document.
Image input creates another possibility. Suppose a browser workflow needs to distinguish a sign-in screen from an error dialog before continuing. You could test a question whose answers describe those known screen states, with a review option for unfamiliar screens. The classification would tell your code which branch to consider; interacting with the browser would remain a separate operation.
Images must be inline base64 data URLs in user messages containing input_image parts. Hosted HTTP or HTTPS image URLs and file_id inputs are unsupported.
These examples are candidates for evaluation. Input support alone doesn't establish how accurately a model will recognize a particular document or interface.
Copy link to headingHow is the Decisions API different from Structured Outputs?
Structured Outputs lets you constrain a model's response to a JSON schema. An enum can restrict a field to a list of categories, so developers can already build classification workflows with general-purpose OpenAI models.
Decisions API returns defined answer types and their probability information. Structured Outputs specifies the shape of a generated response. Classification may only require a category, while a support response may need that category alongside an explanation and extracted details. Define the required output before choosing the interface, then test whether separating the decision improves the completed workflow.
Schema compliance and correct judgment are separate questions. The response can match the schema and still assign a sign-in problem to the wrong team. OpenAI explicitly notes that Structured Outputs can contain mistakes. Evaluate category choices against reviewed examples, regardless of which API returns them.
If you use AI SDK, its decision interface exposes experimental_decide and openai.decisionModel('gpt-6-luna'). That provider calls the native Decisions endpoint, and the deprecated openai.evaluationModel name now resolves to the same factory. Older Responses-based evaluation examples need updating; native OpenAI decision calls do not accept Responses API reasoning options.
Copy link to headingWhere does a bounded decision fall short?
Fixed answer lists can omit the right outcome. If a routing system only offers Billing and Technical support, an account-access request still has to fit somewhere. Include an explicit review path and define when it applies. The review label gives the model another option, but you still need to check whether it uses that option appropriately.
Some questions also require evidence the application hasn't supplied. "Does this customer need a refund?" may depend on the order record and the applicable policy. When a customer says "I was charged twice," the message establishes what they reported; the payment system establishes whether two charges occurred. Retrieve the relevant records before asking a model to assess them.
When an answer triggers an operation, keep the operation's requirements in application code. Selecting Account access can route a ticket, but resetting the account still requires the existing identity checks. The classification result doesn't establish authorization.
Choice and score answers also include a separate confidence field. Test confidence and probability thresholds against reviewed examples before using them to control automated actions.
Copy link to headingHow should you evaluate a decision workflow?
Start by collecting representative inputs and writing down the expected decision for each. Include requests that mention multiple problems and cases where the available context is insufficient. If reviewers disagree about the right team, resolve the routing policy before treating either answer as a model error.
Next, define what each answer does in your application. For the support form, Account access assigns a queue and Needs review creates a triage task. Timeouts, refusals, and failed calls also need a path that preserves the original request. This work is useful before you choose an API because it specifies the behavior you're trying to implement.
Compare the model's answers with that reviewed set. Measure routing errors alongside the fraction of requests sent for review. An application that appears accurate because it sends almost everything to a person may not meet the workload's needs. Measure elapsed time through the whole route, including any fallback, before deciding whether the change helps users.
For an existing implementation to study, Vercel's Jev resource hub links to typed-decision guides and application examples. Those patterns can help you define the questions and downstream behavior you'll test with the Decisions API.
For an existing Jev workflow, compare OpenAI’s Decisions API and Jev by the inputs and answer fields your code needs.
Copy link to headingFrequently asked questions
Copy link to headingIs OpenAI's Decisions API publicly available?
Yes. OpenAI offers Decisions API in public beta. Requests use the dedicated /v1/decisions endpoint.
Copy link to headingWhich model powers Decisions API?
GPT-6 Luna is the supported model for Decisions API. Use the model ID gpt-6-luna in a request to the Decisions endpoint.
Copy link to headingCan I already classify content with Structured Outputs?
Yes. Supported OpenAI models can return categories constrained by a JSON schema. Structured Outputs also lets you define additional response fields when your workflow needs extraction or a written explanation.
Copy link to headingDoes a predefined answer guarantee a correct decision?
No. An allowed answer can still misinterpret the input or reflect an incomplete set of choices. Test decisions against reviewed examples and define how the application handles uncertainty, refusals, and failure.
Copy link to headingCan Decisions API return probabilities and scores?
Yes. Predicate answers estimate whether a condition is true, while choice and score answers include probability distributions and a separate confidence value. Scores are probability-weighted averages of zero-based rubric level indices.