Is OpenAI Building "Decision Models" Too? How Similar Are the Decisions API and Jev?

When a customer sends "I was charged twice," the application first needs to decide whether to route the request to billing or technical support; when a user says "refresh the page," the application needs to select the refresh action immediately. What these tasks require is a decision before any action can proceed.

OpenAI has opened the public beta of the Decisions API to all developers: using GPT-6 Luna to evaluate text and images, returning probabilities that conditions hold, predefined choices, or level-weighted scores directly.

The Decisions API introduces a dedicated endpoint (POST /v1/decisions) for these requirements, currently supporting the gpt-6-luna model. Rather than generating freeform text or explanations, it focuses on directly returning answers to fixed question types.

This is very close to Jev, previously covered on this site: both turn conditional evaluations, choices, and scores into results directly usable by software, accompanied by probabilities, leaving the next step to code. Jev is TypeSafe's dedicated System One decision model; here, OpenAI provides a dedicated API powered by GPT-6 Luna. What they share is their purpose and output format.

Why Is a Dedicated "Multiple-Choice Only" API Needed?

In real-world applications, these "micro-decisions" occur repeatedly at various branch points across workflows: routing user requests to different departments, matching follow-up actions to sales leads, picking an obstacle-avoiding lane from minigame frames, or determining whether a query should call a weather tool or invoke a complex reasoning model.

If relying on the conventional Responses API (OpenAI's primary generation interface for producing natural language or structured content) alongside Structured Outputs (structured outputs, used to constrain model outputs to a predefined JSON schema), the model generates text or schema-compliant objects before handing them over to the program. For requests that merely require picking an existing path, applications can instead use a decision interface that directly returns answers to fixed question types.

Its value lies in letting the application select a path first before entering the corresponding workflow: weather queries go to a weather tool, requests comparing options are routed to a reasoning model, and actions requiring human review enter an audit queue. Such decisions can be placed in front of every incoming request, every UI action, or every image awaiting inspection. Faster and cheaper per decision, it is well-suited to handle these recurring micro-decisions; backend tools still handle execution, and generation interfaces are only called when content needs to be produced.

OpenAI states that the Decisions API makes decisions up to 10x faster compared to invoking the same GPT-6 Luna through the Responses API. This comparison specifically targets decision tasks; applications must still handle network transit and subsequent execution, so this should not be conflated with the entire application running 10x faster.

Three Core Question Types: How Does It Reach Conclusions?

When calling the Decisions API, a request consists of three parts: the specified model (currently gpt-6-luna), shared input content (supporting plain text or mixed text and images), and a questions array. Three question types are supported: predicate for evaluating whether a condition holds true, choice for single-selection among predefined options, and score for scoring across an ordered ladder of levels. In the returned answers array, the API provides the corresponding question name (name), type (type), and calculated answer for each question.

1. Predicate (Condition-Probability Questions)

Used to estimate the probability that a given statement or condition holds true. Rather than outputting a hard True or False, the API returns the model's estimated probability that the condition is true (probability, between 0 and 1), accompanied by the question's name and type.

• Typical applications: Inspecting uploaded product photos for damage such as cracks, tears, or dents; determining whether a piece of text is relevant to the current context.
• Working mechanism: Developers provide clear judgment instructions based on observable criteria. The application layer sets its own decision thresholds according to business tolerance for false positives versus false negatives: the cost of missing a damaged photo differs from flagging an undamaged one, and thresholds should be calibrated using labeled samples from one's own domain.

2. Choice (Unordered Categorical Questions)

Selects the single best-matching option from a set of predefined candidate choices provided by the developer.

• Typical applications: Support ticket triage (categorizing into refund, technical support, shipping, etc.); invocation routing (chit-chat, tool call, or escalating to a reasoning model).
• Working mechanism: The result includes the selected option (choice), the probability distribution across all options (probabilities), and a separate confidence score (confidence). When the predefined category list cannot exhaustively cover all potential inputs, the documentation recommends configuring an "other" option to catch unrepresented categories; conversely, if the model returns low confidence, that represents a separate dimension of evaluation, where the application layer should decide whether to escalate to human review or trigger a fallback based on its own confidence thresholds—the former resolves category gaps, while the latter handles insufficient reliability.

3. Score (Ordered Ladder Scoring Questions)

Used to score input content against a strictly ordered ladder of discrete levels. Rather than freely generating an isolated numerical score, the model produces a probability distribution across all discrete levels, and then computes the probability-weighted average of the levels' numerical indices.

• Typical applications: Issue severity assessment, support ticket priority grading, ordered quality ratings.

• Computation logic: Developers define a set of levels arranged from lowest to highest (levels, with zero-indexed increments). The official documentation illustrates this using software bug severity:

  • Level 0 (Cosmetic): Cosmetic issue only; functionality is unaffected.
  • Level 1 (Workaround available): A task fails, but an alternative workaround exists.
  • Level 2 (Fully blocked): A task fails, and no workaround is available.

  When the input is "Export fails in Safari but works in Chrome," the model's estimated probability distribution might be: 0.1 (10%) for Level 0, 0.7 (70%) for Level 1, and 0.2 (20%) for Level 2. The final returned score is a continuous numerical value calculated by weighting each level index by its probability:

  0 × 10% + 1 × 70% + 2 × 20% = 1.1

  The score 1.1 summarizes the entire probability distribution; it does not introduce an extra "Level 1.1." In this example, Level 1 is the most likely, yet a possibility of falling into Level 2 remains preserved. If business logic only needs a single category, choice should be used; if sorting by severity is required, score makes comparisons much easier.

What Do "Up to 10x Faster" and $0.10 per 1M Input Tokens Really Mean?

The Decisions API features a dedicated pricing mechanism and billing structure:

In terms of pricing, the Decisions API using the gpt-6-luna model is billed exclusively on input tokens at $0.10 per 1M input tokens. Calling this endpoint incurs no output token fees, nor any fees for cache reads or cache writes. This rate applies to the /v1/decisions endpoint and remains subject to regional processing premiums and long-context multiplier billing rules.

High-concurrency applications can estimate costs based on input volume. For example, assuming an average of 1,000 input tokens per request, executing 1 million calls amounts to a cumulative input volume of 1 billion tokens, corresponding to a baseline input cost of $100. This calculation only covers the baseline list price for plain text inputs, excluding tokens generated by image inputs, regional premiums, long-context multipliers, and backend system overhead such as network round trips, voice, or downstream tool execution.

Regarding response speed, the sales lead triage segment in the main thread demo showed server-side response times under 100 milliseconds, but this only represents the server processing time in that specific sales lead demonstration—not an end-to-end figure or a global SLA guarantee. In production deployments, full interaction latency also includes network transit between client and server, local application logic, and the time required for subsequent action execution.

Six Use Cases Doing the Same Thing: Decide First, Then Hand Off to Workflows

In official technical demonstrations, the Decisions API showcased six application entry points spanning routing, discrete labeling, image screening, interface decisions, risk controls, and aggregate analytics:

1. Intelligent routing (Routing): Triage between language models, external tools, and specialized Agents. For instance, simple weather queries directly select the weather tool, while complex analytical requests are routed to a reasoning model. This channels different tasks into appropriate workflows; how much is saved depends on the actual cost of backend tools and models. The monetary amounts in the animation serve as illustrative path costs.
2. Text classification: Rapidly determine categories and prioritize unstructured text. For example, when a user submits "I was charged twice," the API can classify it into the Billing department and evaluate its severity level. The confidence levels and priorities in the demo are illustrative values for display purposes.
3. Visual screening and keyframe filtering (Image analysis): Perform damage inspection, attribute categorization, or image comparison guided by instructions. In the official demo's return inspection at around 10 seconds, given an image of an orange backpack, the interface displays its category (Category: Backpack) and damage assessment (Damage: None detected). Given the API's supported question types, an application can frame "which product category" as a choice question and "is there any damage" as a predicate question, then organize the answers into UI fields. This represents a combination of predefined questions; unconstrained extraction of arbitrary fields still requires generation interfaces. When handling video, the application similarly extracts frames first before passing them to the API to rapidly filter task-relevant keyframes.
4. Assisting interface actions (Computer use): In automation tasks, submit UI screenshots along with a list of available actions to the API to help select the next action (such as choosing "Continue" among candidate controls). The Decisions API is solely responsible for making discrete selections; screen coordinate mapping and click execution must be handled by the outer application.
5. Safety guardrails (Guardrails): Before a system or Agent executes high-risk operations (such as recursively deleting a shared directory), evaluate the risk level using the Decisions API. The application halts execution based on the returned risk evaluation and escalates to human review; permissions and blocking logic remain the responsibility of the application.
6. Pattern and trend analysis (Analytics): Batch-label large datasets to identify aggregate trends. In the official demonstration, product reviews are classified across predefined tags—Positive, Mixed, and Negative—to calculate distributions; the review counts and distributions in the animation are illustrative numbers, not statistics from an actual dataset.

Typical Cases in the Demo: Lead Triage and Lane Selection

In the demo video, the official presentation further showcased practical implementations across two specific scenarios:

• Rapid sales lead triage: When handling incoming sign-ups from diverse sources, the system quickly evaluates intent and scale so differentiated sales pipelines can take over. For example, for an agency team of 2–10 people marked "Ready to buy" and aiming to deploy within the month, the interface marks the next step as "Product demo"; for an individual solo user in the exploratory phase, the interface marks the next step as "Plan comparison." This illustrates the paradigm of using predefined questions for rapid categorization, allowing distinct business workflows to handle the resulting tags.

• Minigame lane selection: In another minigame demo, the system continuously feeds frames depicting three lanes, obstacles, and the player vehicle into the Decisions API, which selects an obstacle-avoiding lane among candidate lanes. When the game speeds up, the display continues to show lane selection and obstacle avoidance. This demonstrates visual evaluation and action selection in a minigame, while actual lane switching is executed by the game engine.

The Voice Conversation Continues While Decisions Picks Actions: How Does the Frog Keep Up?

In voice-controlled scenarios, the Decisions API can work alongside OpenAI's Live API (an interface for bidirectional, low-latency voice conversations). Leveraging the existing Client Delegation pattern in the Live API, voice conversation and action decisions achieve a clean division of labor at the application layer: GPT-Live maintains voice streaming, listening, and speaking, while specific action selections are delegated to the Decisions API.

The standard interaction and execution workflow is as follows:

1. Establish a delegated session: The application starts a Live session configured with client delegation and declares the set of supported actions. When the system receives the session.delegation.created event, it saves the delegation ID (event.delegation.id).
2. Assemble decision input: The application server collects conversation transcripts between the user and assistant, along with the user's latest request, the application's current state (such as active tabs and loading status), and the list of currently available actions (such as back, reload, noop), assembling them into input for the Decisions API.
3. Select and execute the action: The Decisions API selects the target action from available options. Before actual execution, the application verifies whether the request has been cancelled and whether the selected action still aligns with the current UI state; once verified, the application executes the action and updates state.
4. Send back with delegation ID: After the action is executed, the application passes the previously saved delegation ID back to GPT-Live via session.commentary.append, prompting it to inform the user via voice; if only updating context without triggering spoken commentary, session.thinking.append is used.

When encountering complex tasks that go beyond simple interface operations, the Decisions API can also act as a frontend triage router. For example, in a slide deck navigation demo, if a user requests to "compare these two options and recommend one," the Decisions API can classify the choice under reason; the application then invokes the Responses API with a reasoning model for in-depth analysis, and returns the conclusion back to the voice session using the same delegation ID.

In the official technical demonstration, engineers also showcased the pairing of GPT-Live with an animated cartoon frog: GPT-Live handles the voice dialogue, while the Decisions API selects the frog's animated facial expressions based on conversation context. When the user mentions having a "crazy week," GPT-Live replies that it sounds exhausting, and the frog's expression switches to an exhausted look; when the user clarifies that it was "crazy in a good way" and mentions launching a product, GPT-Live responds that it is exciting, and the frog immediately returns to a smiling face. Working in tandem at the application layer, the two achieve a division of labor between spoken responses and visual expression selection.

Before Integrating, Determine: Do You Need a Decision, or New Content?

The Decisions API handles evaluations across fixed question types. When choosing an API, first consider what result your application needs:

Suitable Use Cases

• Discrete conditions and probability estimation: Evaluating whether a condition holds true and obtaining a probability estimate, which the application layer converts into decision logic based on business-defined thresholds, rather than relying on the API to directly output binary conclusions.
• Closed-set discrete decisions: Such as routing support tickets, selecting the next interface action, or dispatching request paths.
• Rubric-based ladder scoring: Scoring issue severity or priority across discrete levels according to fixed criteria and obtaining a weighted numerical value.

Unsuitable Use Cases and Engineering Details

• Requiring long text outputs or explanations: The Decisions API only outputs fixed-format decision data and does not provide natural language explanations. If generating text or detailed reasoning is required, the standard Responses API should be used.
• Requiring dynamic JSON field extraction: If arbitrary structured entities such as contacts, amounts, or line-item tables must be extracted from input text, use Structured Outputs from the Responses API (structured outputs).
• Requiring parameterized tool calls: If the model needs to generate tool parameters autonomously (such as constructing conditional queries or assembling API parameters), Function Calling (function calling) is still required.
• Key engineering considerations:
  • Design questions around observable criteria: Questions should be grounded in clear, observable, and objective standards, with separate dimensions split into distinct questions; category options (choices) must be clearly defined with distinct boundaries; adjacent tiers in ladder scoring (levels) need non-overlapping, concrete criteria so that each answer maps to interpretable rationale.
  • Batch independent questions, split dependent ones: In a single request's questions array, multiple mutually independent questions sharing the same input data can be submitted simultaneously (for example, checking a product image for damage while simultaneously classifying its category); however, if subsequent questions depend on answers to earlier ones, they must be split into separate, sequential requests.
  • Question naming: Each question should be assigned a unique name; the API echoes this field verbatim in the response, enabling the application layer to parse and match answers accurately.
  • Image input format: The current endpoint only supports submitting images via embedded Base64 Data URLs; hosted HTTP/HTTPS image URLs or file_id references are not supported.

In production architectures, the Decisions API is solely responsible for returning probabilities, selections, and weighted scores based on developer-defined questions and options, while threshold decisions, workflow gating, fallback handling, and downstream action execution remain the responsibility of the application layer.