OpenAI Decisions API or Responses API? How to Choose in 2026

OpenAI’s API documentation describes Decisions API as a public beta using GPT-6 Luna through the dedicated /v1/decisions endpoint (Decisions API guide). Choose it when a task ends in a typed judgment—such as selecting a fixed option, checking a condition, or assigning a rubric score. Keep Responses API for custom structured content, explanations, and requests to call tools. You can use both in one Agent flow; don’t migrate based only on a speed claim or an API name.

This is for developers choosing an API for classification, routing, or priority decisions; platform engineers separating judgment from tool execution; and technical leads planning an evaluation, migration, or dual-track rollout.

Last updated October 8, 2026; status, endpoint, supported answer types, pricing notes, and interface guidance checked against OpenAI’s Decisions guide, API reference, and API changelog.

Output contracts determine the first choice

Start with the output your application must consume—not the fact that both interfaces can return machine-readable data.

OpenAI documents three typed answer kinds for Decisions API: predicate, choice, and score. That gives you a useful boundary:

• Use predicate when the downstream system needs a condition answered as true or false.
• Use choice when the system must select among named alternatives.
• Use score when the task applies an explicit scoring standard.

The API reference describes the request’s input, question types, and answer names. Treat those as part of your application contract: define the evidence the model receives, the judgment being requested, and the name your code expects for the answer. See the create-decision API reference for the documented request and response shape.

Responses API is the better fit when your contract asks for more than a typed judgment: for example, a custom object with several related fields, a rationale written for a reviewer, or content whose structure changes with the task. OpenAI’s Structured Outputs guide covers structured output with Responses API. A JSON response is not automatically the same thing as a decision. If the application needs a fixed answer from a known set, decide whether the typed answer contract is a better match than asking for a generated object and validating it yourself.

Where does OpenAI Decisions API fit in classification and routing? It is worth evaluating when a classification task has a defined set of outcomes and a clear mapping from each outcome to an application route. If the model must instead draft a message, summarize evidence, or explain a complex exception in custom fields, Responses API is the more natural interface for that generation step.

For instance, a support workflow might first classify an incoming request into fixed handling routes. A later stage could generate a tailored response or request a tool action. The first stage is a candidate for Decisions API; the later stage is not automatically one. Keep these stages separate in the design, so a change to the judgment does not silently change what the Agent is authorized to do.

Review the contract before changing the endpoint. If a downstream consumer expects prose, a flexible object, or a rationale, replacing that output with a typed answer may force a second generation step. Include that step in your design and evaluation rather than assuming the decision answer covers it.

Tool execution belongs to a separate stage

A typed decision is not an instruction that the API has executed. Decisions API is documented for conditions, fixed choices, and rubric-based evaluation; it does not, by itself, perform your business action, call your application’s tools, or complete an Agent task.

Responses API can be used when the model needs to request a tool call. OpenAI’s function calling guide explains that tool flow. Your application still owns the execution boundary: it receives the request, applies authorization and validation, runs the tool, and decides what to return to the model.

Can Decisions API replace an Agent’s tool call? No—not when the workflow needs the model to request an action or produce the arguments for an application tool. Use Responses API for that stage, or split the workflow: have Decisions API choose or classify, then let a controlled application component route the result into a later Responses API call or another approved executor.

This separation is useful when the judgment and the action have different risk profiles. A routing choice can be constrained to a defined set of destinations, while the action stage can validate arguments and apply permissions. It also makes failure handling clearer: a valid classification does not prove that a tool request is safe, that a tool succeeded, or that a resulting change should be accepted.

When reviewing an Agent design, identify which component owns each responsibility:

• Judgment: classify evidence, test a condition, or score against a rubric.
• Generation: create custom fields, summaries, explanations, or user-facing text.
• Tool request: propose a call and its arguments through the supported tool flow.
• Execution: validate permissions, invoke the business system, and handle its result.

A design that blurs these steps can make testing harder. If a route is wrong, you need to know whether the judgment failed, the route mapping was incorrect, or the executor applied the wrong action. An explicit handoff gives you a place to log and test each boundary.

Shared evidence does not mean shared dependencies

Decisions API can be evaluated for workflows where multiple independent questions use the same evidence. Before combining them, write down each question and determine whether its answer can be judged directly from the original input.

The key distinction is dependency. If two judgments can each be made from the same evidence without relying on the other’s result, they may be candidates for one request design, subject to the documented input and question schema. If the second judgment depends on the first answer—for example, it needs a different evidence set or a conditional follow-up—treat that dependency as a separate stage unless the current API documentation explicitly supports the behavior you need.

Do not infer parallel execution, latency guarantees, or a particular evaluation order from the ability to define multiple questions. The official Decisions API documentation and API reference describe the supported request concepts; build only on the documented behavior, and verify any operational assumption in your own integration.

A practical design review asks:

• Does every question use the same source material?
• Can each answer be evaluated without seeing another answer?
• Does one answer change which evidence or question comes next?
• Does the application need one combined result, or does it need to act after an intermediate judgment?

If the answers are independent, test whether one request is simpler and reliable enough for the workflow. If they are dependent, make the sequence explicit. That may add a call, but it also avoids hiding conditional logic inside a request shape that your team has not verified.

Evaluation evidence matters more than a returned score

A score is an API answer type, not proof that the score is calibrated for your business. A choice distribution or other probability-like value is also an output to assess—not a promise that a particular route is safe. Set thresholds only after testing against labeled examples that resemble the data and edge cases your system will actually see.

How should you use existing task evaluations to assess Decisions API? Reuse a representative, labeled sample, but define the expected answer contract before running the comparison. For every case, record the intended label or acceptable score range, the result from each interface, whether a human reviewer would accept it, and the cost of a false positive or false negative. Then inspect errors by category instead of relying only on one aggregate quality measure.

A useful evaluation plan includes:

• Representative inputs: routine cases, ambiguous cases, incomplete evidence, and examples close to route boundaries.
• Business-weighted errors: separate mistakes that cause harmful routing from mistakes that merely send a case for review.
• Review thresholds: decide which outputs can proceed automatically and which must go to a human or a conservative fallback.
• Comparable outputs: compare the typed judgment with the actual requirement, not with a generated explanation that the task does not need.
• Regression checks: preserve a test set for later model, prompt, schema, or endpoint changes.

OpenAI’s evaluation best-practices guide is a useful reference for structuring that work. The decision to deploy still depends on your labels, acceptable error rates, and business consequences. If an incorrect route has a high impact, a strong average result may not be enough; you may need human review for borderline cases or a fallback that avoids irreversible action.

A local comparison should also include failure behavior. Test what your application does when an answer is missing, invalid for the expected contract, or inconsistent with downstream rules. Define whether the workflow retries, asks for review, falls back to Responses API, or stops. Treat those as product decisions, not as guarantees supplied by the answer type.

Total workload cost includes the stages around the call

Don’t compare interfaces using a single latency figure or the apparent simplicity of one request. Model the whole task: input length, number of questions, any repeated calls, generation needed afterward, human review, and the application work required to consume and validate the output.

OpenAI describes a speed comparison for Decisions API in its own materials. If you see a claim such as “up to ten times faster,” keep it attributed to OpenAI and within the comparison’s stated scope; it is not a guarantee that your workflow will be faster, cheaper, or better. A workflow that needs a separate explanation or tool call may have a different end-to-end profile from a fixed-answer judgment. Check the official API changelog and Decisions documentation for the current wording before using a launch comparison in planning.

For cost, map the real call structure instead of multiplying a headline rate by an assumed request count. Include the actual input sent, how often the task is repeated, whether a follow-up Responses API call is needed, the cost of rejected or retried work, and review time. OpenAI’s pricing page is the source to consult for current billing details. The Decisions guide also describes its billing characteristics; verify the current documentation for the model and endpoint you plan to use.

A short cost worksheet can make the trade-off visible without pretending to know the result in advance:

• List each model call in the production path.
• Estimate input and output using representative task records.
• Add retry and review scenarios observed in your evaluation.
• Compare the full workflow against the existing Responses API path.
• Recalculate when the model, endpoint, input pattern, or billing terms change.

The outcome may favor Decisions API for a narrow judgment stage and Responses API for the rest. It may also show that a second call removes the expected benefit. Make the decision from the evaluated workload, not from a general speed statement.

Runtime and data boundaries shape the rollout

As documented for this review, Decisions API is in public beta, uses GPT-6 Luna, and has a dedicated /v1/decisions endpoint. The documented answer types are predicate, choice, and score. These are specific scope details, not a promise that every model, endpoint, account, or processing configuration is supported. Check the Decisions guide and API changelog again before launch; beta status and supported scope can change.

A beta endpoint may be unsuitable as a default for a workflow with strict availability or change-control requirements. That does not mean you must avoid it. It means the team should decide whether it can isolate a pilot, detect changes, and fall back safely without confusing test behavior with production readiness.

Data handling is another gate. Confirm that your input can be sent under your organization’s policy, and review the relevant retention, processing, and eligibility terms for the account and workload. The OpenAI data controls documentation is the appropriate starting point for those questions. Don’t infer regional processing or eligibility from the endpoint name; verify the currently documented terms that apply to your deployment.

Use this decision checklist before selecting a rollout path:

• [ ] The task ends in a predicate, a choice from defined options, or a rubric-based score.
• [ ] The request’s evidence and named answers match the current documented Decisions API schema.
• [ ] Any dependent questions are separated into explicit stages unless documented behavior supports the required dependency.
• [ ] Tool requests, business execution, authorization, and post-action checks remain under an explicitly tested application flow.
• [ ] A labeled sample covers routine, ambiguous, and high-impact cases, with false-positive and false-negative costs considered.
• [ ] Review thresholds and fallback behavior are defined for uncertain, invalid, or incomplete results.
• [ ] Cost and latency are assessed across the complete call sequence, including retries, review, and any later Responses API request.
• [ ] The public-beta status, supported model and endpoint scope, and applicable data requirements are acceptable to the team.

A pilot, dual track, or hold decision

Use a pilot when the task has a narrow typed output contract, a representative labeled set is available, and a fallback is straightforward. Keep the pilot focused on one judgment stage so you can compare output quality and end-to-end behavior without changing the Agent’s execution permissions at the same time.

Use a dual track when Decisions API appears suitable for fixed judgments but Responses API remains necessary for generation or tool requests. This is often the clearest architecture when an Agent contains both bounded routing and flexible follow-up. Keep the interface boundary visible in logs and evaluation records so failures can be attributed to the right stage.

When should you keep using Responses API for JSON? Keep it when your output needs custom fields, explanatory text, or a structure tailored to the task rather than a typed judgment from the documented answer kinds. Also keep it where the same model interaction must request a tool call. Revisit the choice only after you can show that the required output contract maps cleanly to Decisions API and that the full workflow benefits.

Choose a hold when the workflow depends on unsupported or unverified behavior, data review is incomplete, or the cost of a wrong decision is not controlled by human review or a safe fallback. A hold is not a rejection of the interface; it is a decision not to make an operational dependency before the evidence and safeguards are ready.

We’d run the comparison on existing labeled tasks, inspect error types, and calculate the full call path before moving a production route. If your current setup is a single Responses API flow, its drawback may be that a fixed judgment is bundled with generation or tool handling; if it is split across loosely monitored calls, the drawback may be harder failure attribution and cost accounting. Neither problem requires a Mac: these API decisions are independent of Apple hardware. A Mac becomes relevant only if the same project also needs native iOS or macOS builds, device testing, or Apple-toolchain acceptance work. For a temporary macOS environment, renting a Mac through zekmac can be more practical than tying up a developer’s machine or buying hardware for a short-lived delivery window. For continuous, long-running workloads or work that requires direct physical interfaces, compare ownership and local capacity instead.