AI apps are no longer just about generating text. They are increasingly about deciding what happens next. Which model should handle a request? Is this customer ticket urgent? Did an agent’s output meet the quality bar? Should a workflow continue, retry, or escalate to a human?
On October 22, 2026, OpenAI answered this need by making the Decisions API generally available. The Decisions API is a purpose-built endpoint that returns structured answers — a predicate, a choice, or a score — instead of a full generative response. Powered by GPT-6 Luna, it is designed to make fast, focused decisions across AI applications and agentic workflows, without the overhead of traditional generative inference for every step.
In this guide, we break down what the Decisions API is, how it works, what it costs, and how early customers are using it in production.
What Is the OpenAI Decisions API?
The Decisions API is a dedicated endpoint — /v1/decisions — that turns text, images, and structured inputs into actionable choices, probabilities, and scores. Where the Responses API generates a full answer, the Decisions API is built for the control flow of an application: the small, high-frequency judgment calls that decide what a system does next.
OpenAI positions it as a new class of model capability. Sometimes you need a model to create. Sometimes you need it to reason deeply over a complex problem. And sometimes the most valuable thing a model can do is make a focused decision that helps the rest of the system move forward. The Decisions API is built for that third case.
It is powered by GPT-6 Luna and accepts three kinds of outputs:
- Predicates — estimate the probability that a statement is true.
- Choices — select among a defined set of options.
- Scores — rate an input against a numeric scale.
Because these outputs are structured by design, the Decisions API removes the need to parse free-form text and coax a reliable result out of a general-purpose chat model.
How the Decisions API Works
Developers send a request to the dedicated Decisions endpoint with the inputs they want evaluated and the questions they want answered. The API returns a structured, machine-readable result rather than prose.
A typical request includes:
- model — the GPT-6 Luna deployment (in Azure OpenAI, the model is exposed through the /openai/v1/decisions endpoint).
- input — text, an image URL, or structured data to evaluate.
- questions — an array of decision questions, each of a boolean (predicate), choice, or score type.
The response comes back as a decisions object, mapping each question name to its value and probability. This clean contract makes the API straightforward to drop into routing logic, guardrails, evaluation pipelines, and agent orchestration.
The API supports up to 400 questions per request, native JSON output, and image inputs, which makes it practical for batching many judgment calls in a single call.
Pricing: Input-Only, No Output Charges
One of the most notable things about the Decisions API is its pricing model. You pay only for input tokens. There are no output-token charges, and no cache-read or cache-write charges on the base tier.
As of general availability, pricing is USD 0.10 per 1M input tokens, with no output charges. Cached input costs USD 0.01 per 1M tokens.
This input-only structure reflects the nature of the workload: a decision produces a tiny, structured output, so the economics are dominated by what you feed in. For teams running hundreds or thousands of small decisions across a workflow, it can be dramatically cheaper than routing every step through a full generative model.
GA Features and Availability
The general availability release brings several capabilities beyond the earlier public beta:
- Prompt caching to reduce cost on repeated context.
- Data residency options for US and EU, important for compliance-sensitive workloads.
- Support for up to 400 questions per request.
- Native JSON output for clean integration.
- Image inputs alongside text and structured data.
The Decisions API is available today through OpenAI’s dedicated Decisions endpoint, and simultaneously through Azure OpenAI in Microsoft Foundry, where it can be tried directly.
Who Is Using the Decisions API
Several organizations were quoted at launch as early adopters. Datadog, Speak, Sierra, Box, and Ramp are among the companies using the Decisions API to power routing, evaluation, and agentic decision-making in production.
The common pattern across these customers is the same: replace brittle, hand-written rules or costly full-model calls with a purpose-built decision endpoint that returns a reliable, structured result. For a platform like Datadog, that might mean triaging alerts or classifying support questions. For a product like Ramp, it might mean deciding whether an expense submission meets policy before a human ever sees it.
Real-World Use Cases
The Decisions API shines anywhere an application needs frequent, low-latency judgment calls. Common use cases include:
- Model routing — choose the right model for a given request based on complexity and cost.
- Guardrails and policy checks — evaluate whether an output meets safety or compliance criteria before it is shown to a user.
- Content classification and moderation — decide if content is urgent, spam, or sensitive.
- Agent workflow control — decide whether to continue, retry, or escalate a task to a human.
- Evaluation and quality gates — score responses against a rubric to gate deployments.
The thread that connects all of these is efficiency. Not every step in an AI workflow needs a full generative response, and the Decisions API lets developers apply the right kind of intelligence to the right moment.
Why This Matters for the Coming Wave of AI Agents
The Decisions API matters because it signals a shift in how AI applications are being built. The next generation of AI applications will not just be defined by how well they generate — they will also be defined by how intelligently and efficiently they decide what to do next.
As agents become more sophisticated, the number of small decisions a system makes explodes. A single workflow can involve hundreds or thousands of routing, validation, and escalation judgments. Running each of those through a full generative model is slow and expensive. A dedicated decision endpoint gives developers a tool purpose-built for that layer of the stack.
For developers building agentic systems, the Decisions API is a practical new primitive: a fast, cheap, structured way to bring intelligence into the control flow of an application.
Getting Started
If you are building on Azure, you can try the Decisions API in Microsoft Foundry. OpenAI also provides developer documentation and a guide to building and evaluating your first decision with GPT-6 Luna.
A good first step is to identify a single high-frequency judgment call in your workflow — a routing rule, a classification task, or a quality check — and prototype it against the Decisions endpoint. Because the output is structured, the integration is usually simpler than wrapping a general-purpose model.
The Decisions API is generally available today. For teams already running agents in production, it is worth evaluating against the rules and full-model calls you currently rely on.
