OpenAI DevDay 2026 · Developer guide
Let software make the small decisions quickly.
OpenAI's Decisions API is described as a low-latency interface for choosing one answer from a developer-defined set. It targets classification, routing, and the next bounded action in an agent workflow—not open-ended text generation.
This page summarizes the limited-preview information reported around DevDay 2026. The public request schema, pricing, and performance guarantees may change as access expands.
Reported engine
GPT-6 Luna variant
Reported speed
~150 ms
Context
Text + images
Result
One bounded answer
Coverage describes a specialized decision path that is roughly ten times faster than a regular GPT-6 Luna API call.
Availability status
OpenAI Decisions API is not available yet
The service is still in limited preview and cannot be used through the public OpenAI platform yet.
As soon as it opens, it will be available first on thejevai.
What it is for
A decision layer between context and action
A general-purpose model can explain many possibilities. A decision API is useful when your application already knows the allowed branches and needs one compact result that code can consume.
Classify incoming context
Choose a label for a support request, document, moderation event, or other piece of text or visual input.
Route to the right path
Send a request to billing, sales, a specialist model, a queue, or a human review step without parsing a paragraph first.
Pick the next agent move
Use a bounded choice to select a tool, a retry, an escalation, or the next action in a larger agent loop.
What changes compared with a normal LLM call
The model is asked to choose, not to write.
A normal generation request can return a useful paragraph, but your application then has to interpret it. The Decisions API moves the answer space into the request so the next step is explicit.
Prompt shape
An open instruction with room for explanation, alternatives, and free-form language.
A question paired with a finite set of answers defined by the developer.
Output shape
Text or structured content that may still need validation and parsing.
One selected answer and a reported confidence value for the application to consume.
Application work
Read the response, extract intent, handle unexpected wording, and decide whether it is safe to act.
Map the returned answer to a known branch, then apply deterministic policy checks.
Best fit
Planning, explanation, synthesis, tool orchestration, and tasks where the answer is not known in advance.
Repeated micro-decisions such as route, allow, escalate, retry, or choose a next tool.
Where it sits in OpenAI's API stack
Use the Luna context carefully.
OpenAI's public model documentation helps explain the surrounding platform, but the Decisions API preview should be treated as its own product surface until its endpoint and billing rules are published.
Luna is the efficiency layer
OpenAI positions GPT-6 Luna for focused, high-volume workloads. That makes it a plausible base for fast repeated choices, while the Decisions API adds a bounded answer contract on top.
Text and images are part of the context
OpenAI's current model documentation describes text and image input for the GPT-6 family. Preview coverage also describes Decisions API context as text or image, which expands routing beyond text-only tickets.
Do not copy standard Luna pricing
The regular GPT-6 Luna API is listed at $0.10 per million input tokens and $0.50 per million output tokens. Those figures are a reference for standard Luna calls, not a published Decisions API price.
The preview boundary still matters
The exact endpoint, SDK surface, answer-count limits, quotas, error behavior, and data controls for Decisions API remain separate questions. Keep them behind a small provider interface.
The DevDay context
OpenAI is optimizing both the agent and its decisions.
The Decisions API was announced alongside a broader push to make agent work more usable in production: agents can operate software, security work can continue in the cloud, and token generation can be accelerated for teams that pay for the premium tier.
Agents API
From reasoning to computer use
The Agents API adds Computer Use so an agent can operate software rather than only describe what a person should click. That makes the small routing decision before the action more valuable.
Decisions API
A fast branch inside the loop
The new decision surface handles the narrow choice—classify, route, or select the next action—while the larger agent remains responsible for understanding the task.
Ultrafast
Latency is now a product tier
OpenAI also announced Ultrafast for higher token-generation speed at a premium price. Decisions API addresses a different bottleneck: making a bounded choice without generating a long response.
A useful architecture
Keep reasoning open-ended and execution bounded.
The Decisions API is best understood as one fast gate inside an application. Your orchestrator frames the task; deterministic code still owns permissions and consequential actions.
Frame the task
Use an agent or general model to understand the request and identify the small decision that is needed next.
Pass relevant context
Send the text or image state needed for that decision instead of replaying an entire conversation or tool trace.
Ask one bounded question
Define the allowed answers—route, allow, block, score, or next action—and let the model select one.
Enforce policy in code
Apply thresholds, permissions, rate limits, and human approval before the result can trigger a real-world action.
The contract
Small input. Explicit answer space.
Public descriptions point to a request made of context, a question, and a finite list of acceptable answers. The response is meant to be consumed directly by application code.
Text and image context are both reported as supported. The exact multimodal limits and stable SDK shape still need to be confirmed in the official preview documentation.
{
"context": "I was charged twice and need a refund.",
"question": "Which team should handle this?",
"answers": ["billing", "technical", "other"]
}{
"answer": "billing",
"confidence": 0.94
}The snippets are intentionally conceptual. They illustrate the decision contract described in public coverage and are not a guaranteed OpenAI SDK request body.
Before you build around it
Preview claims are a starting point, not a production contract.
The most important engineering work is measuring the boundary around the model: the schema, the score, the failure modes, and the policy that decides what happens next.
Verify the schema
Confirm the endpoint, SDK support, answer limits, error shape, and how abstention or invalid answers are represented.
Wait for pricing
Preview coverage did not include a public price list. Model routing decisions should have a clear cost baseline before launch.
Test confidence
A confidence score is not automatically a calibrated probability. Compare score bands with observed outcomes on labeled data.
Plan for change
Limited preview access and evolving contracts call for a feature flag, a fallback path, and a provider boundary in your code.
Questions developers will ask
What is known, and what is still a preview detail?
Can every developer use the Decisions API now?+
No. Public coverage describes an invite-only limited preview, with a broader rollout expected later. Treat access as changeable and keep a provider fallback until availability and quotas are documented.
Is there a public price for Decisions API?+
The preview reports did not publish a dedicated price list. Calculate the value of the faster decision path, but do not hard-code a cost assumption into your product plan before official pricing is available.
Can the confidence value be used as a probability?+
Not automatically. Public analysis describes the value as model-reported rather than independently calibrated. Measure score bands against labeled outcomes and use thresholds, abstention, or human review for consequential actions.
Is the conceptual JSON example an official SDK payload?+
No. It shows the public idea—context, question, and allowed answers—without pretending that the preview request body, field names, limits, or error responses are stable.
Need a decision model you can try today?
Use Jev to prototype typed classification, routing, scoring, and safety checks while the Decisions API preview develops.