OpenAI Decisions API Goes GA: What Typed AI Decisions Mean for Faster Apps

TL;DR

OpenAI's Decisions API became generally available with GPT-6 Luna on October 22, 2026. It is designed for applications that need a typed judgment rather than a long generated answer: whether content meets a rule, which option best fits a request, or how a case scores against a rubric. OpenAI says the endpoint evaluates text, images, and JSON and returns decisions about ten times faster than the Responses API.

The important change is architectural. Instead of asking a general-purpose model to explain a classification and then parsing its prose, a product can ask focused questions and receive structured answers that are easier to route, store, test, and monitor. The release adds shared prompt caching, images attached to individual questions, direct JSON input, hosted image URLs, conversation history, up to 400 questions per request, and native GPT-Live integration. These features make the API relevant to moderation, triage, recommendation, document processing, and other software workflows where consistency matters more than eloquence.

Builders comparing AI utilities, automation software, and developer tools can also use the BTTC software catalog to find established applications for the parts of a workflow that need a durable interface, permissions, or human review.

What the Decisions API is for

The Decisions API is not positioned as a replacement for every chat or generation endpoint. Its job is narrower: turn evidence into an answer that an application can act on. OpenAI's guide describes examples such as classifying content, routing requests, prioritizing work, checking a condition, choosing from a fixed set, or assigning a score against a rubric.

That distinction matters because many production applications do not need a paragraph. A support queue may need an urgency label and a confidence signal. A marketplace may need to decide which category fits a listing. A security workflow may need to ask several policy questions about the same text or image. A recruiting tool may need to check whether a document contains required fields before sending it to a human reviewer. In each case, the output becomes part of a larger program rather than the final user-facing response.

The API still depends on good question design. A typed answer does not make an ambiguous rule precise. Teams need to define the evidence, allowed choices, thresholds, and fallback behavior before they optimize latency.

Why general availability is significant

The public beta already established the basic idea, but general availability is a stronger signal for teams deciding whether to build around an endpoint. The current guide says requests use POST /v1/decisions with gpt-6-luna, and the service now supports up to 400 questions in one request, up from 200 during the beta. That higher ceiling can reduce orchestration overhead when many related checks share the same evidence.

The endpoint also supports prompt caching. If many requests reuse shared instructions, policies, examples, or reference material, caching can reduce repeated input work and make a high-volume classifier easier to operate. Caching is not a substitute for measuring real costs: cache hit rates, input size, question count, retries, and downstream review time all affect the economics.

General availability should therefore be read as permission to evaluate the API seriously, not as a reason to skip an application-specific benchmark. Compare it with the Responses API using your own representative data, error tolerance, image mix, latency target, and human escalation path.

The new inputs change the design space

Three additions are especially practical. First, developers can pass structured data directly as JSON instead of flattening every record into a long prompt. That is useful for product metadata, form submissions, event records, and other inputs that already have a schema.

Second, images can be attached to individual question instructions. An application can give the model shared evidence and then ask different questions with question-specific images. This supports visual inspection, document checks, screenshot comparison, and product review flows without forcing every image into every question. Public HTTP or HTTPS image URLs and inline base64 data URLs are supported according to the guide.

Third, conversation history can be evaluated alongside function calls, custom tool calls, and their outputs. This makes Decisions more useful inside an agent loop. A voice or chat application can let GPT-Live call Decisions directly, or trigger a decision when transcript input or output changes. The result is a separation between conversation and policy: the user can speak naturally while deterministic application code still receives a narrow decision object.

Where teams should be careful

Typed output improves integration, but it does not guarantee truth, fairness, or suitability for high-stakes use. A classifier can be consistently wrong when its rubric is incomplete. A score can look precise while hiding uncertainty. Image-based judgments can fail when a camera angle, language, or document format differs from the evaluation set.

Before shipping, build a test set that includes normal cases, borderline cases, adversarial inputs, missing evidence, and examples that should be escalated. Log the input version, policy version, model, decision, and human outcome where privacy rules allow. Keep a fallback for timeouts and malformed results. If the decision affects health, employment, credit, safety, or access to essential services, involve qualified reviewers and applicable compliance teams rather than treating an API response as an automatic verdict.

The product boundary matters too. An API can return a decision quickly, but users may still need a queue, audit trail, correction workflow, permissions, and an explanation. Those are software features, not model settings. BTTC's software directory is a useful starting point when a workflow needs a maintained application instead of a raw API call.

A practical evaluation checklist

Start with one narrow decision that has a clear success definition. Write the rubric in plain language, list the allowed output values, and create a small labeled dataset. Measure precision and recall where appropriate, but also measure abstention quality, latency percentiles, token usage, cache hit rate, and the percentage of cases sent to humans.

Then compare three implementation choices: a conventional rules engine, a general model endpoint such as Responses, and Decisions. Some tasks are better solved with deterministic code. Others need rich generation. Decisions is most attractive in the middle: evidence is messy, but the action space is bounded and the application needs a typed result.

Finally, expose the decision boundary in the product. Let operators see why an item was routed, correct mistakes, and update the rubric without silently changing history. Faster automation is valuable only when people can understand and recover from its failures.

FAQ

What is the OpenAI Decisions API?

It is an API for turning text, images, or JSON into typed decisions such as a boolean condition, a fixed choice, or a rubric score that an application can use for classification, routing, and prioritization.

Is it a replacement for the Responses API?

No. Decisions is optimized for bounded judgments and structured outputs, while Responses is better suited to general generation, tool use, and rich multi-step answers. Teams should benchmark both against their real workflow.

What model does it use?

OpenAI's current guide says the endpoint uses gpt-6-luna, which is the only currently supported model for Decisions.

Can it process images and JSON?

Yes. The generally available release supports images in question instructions, publicly accessible image URLs or inline base64 data URLs, and structured JSON input.

When should a team avoid automatic decisions?

Avoid treating model output as a final verdict when errors can seriously affect a person's health, employment, credit, safety, or access. Use qualified review, clear escalation, and appropriate compliance controls.

Conclusion

The Decisions API turns a common AI engineering problem into a more explicit contract: provide evidence, ask bounded questions, and receive typed answers that software can route and measure. Its general availability, larger batches, caching, JSON and image inputs, conversation history, and GPT-Live integration make it a practical candidate for classification and triage systems. The best implementations will not confuse speed with certainty. They will pair the endpoint with clear rubrics, evaluation data, auditability, human escalation, and a durable product interface.