OpenAI Decisions API GA: Features, Latency, and gpt-6-luna
The OpenAI Decisions API is generally available with gpt-6-luna, supporting 400 questions, native JSON, prompt caching, and 10x faster evaluations.
- The Decisions API has graduated to general availability on POST /v1/decisions exclusively using gpt-6-luna.
- Per-request capacity doubles from 200 questions in public beta to 400 questions at GA.
- New capabilities include prompt caching discounts, direct input_json parts, question-level image instructions, and hosted image URLs.
- Responses arrive about 10x faster than the Responses API by returning discrete typed outputs rather than freeform text.
OpenAI Decisions API Reaches General Availability
On 2026-10-22, OpenAI published an update in the OpenAI API changelog announcing the general availability of the Decisions API. The service targets deterministic evaluation workflows such as ticket triage, content moderation, image inspection, and automated routing. Instead of generating arbitrary generative tokens, the endpoint produces structured, typed judgments about 10x faster than the standard Responses API.
The endpoint operates under POST /v1/decisions and currently supports gpt-6-luna as its sole evaluation model. For teams monitoring runtime operational expenses, gpt-6-luna rates are listed at $0.1 per 1M input tokens, $0.01 per 1M cached input tokens, and $0.5 per 1M output tokens. You can model projected token spend across workload volumes on the /tools/llm-api-cost-calculator/ or compare rates across models on the /tools/llm-api-pricing/ index.
- Endpoint: POST /v1/decisions
- Supported evaluation engine: gpt-6-luna
- Release stage: General Availability as of 2026-10-22
- Speed profile: roughly 10x lower latency than the Responses API
- Interactive prototyping: available through the web Playground at https://platform.openai.com/decisions
What Changed Since the Public Beta
The transition from public beta brings several architectural expansions designed to lower round-trip latency and simplify data delivery. The maximum question capacity has increased to 400 questions per request, doubling the previous ceiling of 200 questions. This allows developers to batch extensive checklists against a single shared body of context in one network call.
Cost optimization is also improved through prompt caching support. When applications evaluate recurring contexts or large corpora across multiple queries, cached tokens receive reduced prompt rates. In addition, the API introduced native JSON ingestion, question-level instruction images, hosted web images, rich conversation history evaluation, Private Link support, and native integration with voice workflows detailed in our guide on decisions integration in GPT-Live.
| Feature | Public Beta Status | General Availability Status |
|---|---|---|
| Questions per request | Up to 200 questions | Up to 400 questions |
| Input JSON support | Requires stringifying objects into text | Direct input_json content part |
| Prompt caching | Unsupported on endpoint | Supported with cache discount pricing |
| Image inputs | Inline base64 data URLs only | Inline base64 and hosted HTTP/HTTPS URLs |
| Question image instructions | Shared input context only | Unique images directly inside question instructions |
Question Architectures: Predicate, Choice, and Score
The Decisions API accepts a top-level questions array. Every question entry requires a unique name attribute that the API echoes back in the output answers array, preventing ambiguous mapping when processing batch runs. The engine organizes logic into three distinct types: predicate, choice, and score.
- predicate: Evaluates boolean states or conditions, outputting a probability field ranging continuously from 0 to 1.
- choice: Picks a single matching label from an array of predefined choices, returning a choice string.
- score: Evaluates an input against ordered numeric increments, returning a probability-weighted average score across level indices.
Choosing between choice and score depends on the data topology. Unordered classifications such as routing a ticket to billing or shipping should use choice. In contrast, graded attributes such as incident priority or damage severity benefit from score, which yields fine-grained numeric precision between integer levels.
{
"model": "gpt-6-luna",
"input": "I was charged twice for my order.",
"questions": [
{
"type": "choice",
"name": "department",
"instructions": "Which department should handle this complaint?",
"choices": [
{"value": "billing", "description": "Payments, invoices, and refunds."},
{"value": "technical", "description": "Problems using the product."},
{"value": "shipping", "description": "Delivery and tracking."},
{"value": "other", "description": "Requests outside these categories."}
]
}
]
}
Ingesting Structured JSON, Conversations, and Images
Developers are no longer forced to serialize structured payloads into string blocks. By using the input_json part type inside a user message, raw JSON objects or arrays can be embedded directly within data. Keys placed inside data are handled strictly as data elements; key names like role or image_url do not trigger downstream parsing side-effects.
{
"model": "gpt-6-luna",
"input": [
{
"role": "user",
"content": [
{
"type": "input_text",
"text": "Evaluate the ticket using the order evidence."
},
{
"type": "input_json",
"data": {
"ticket": { "body": "Please refund the duplicate charge." },
"order": { "charges": [49, 49] }
}
}
]
}
],
"questions": [
{
"type": "predicate",
"name": "duplicate_charge",
"instructions": "Does the ticket describe a duplicate charge supported by the order?"
}
]
}
Beyond JSON, the API accepts multi-turn conversation logs. Developers can submit message lists containing system or developer context, assistant dialogue, and tool execution logs. Function and custom tool outputs are linked to prior executions via call_id. For multimodal workloads, images can be submitted via publicly available HTTP/HTTPS endpoints or inline base64 data URLs. Instructions themselves can hold independent image payloads to compare multiple candidate images against one shared baseline image.
Comparing Decisions to Structured Outputs and Tools
Selecting the right OpenAI abstraction requires matching output requirements to API capabilities. The Decisions API does not emit free-form text or elaborate schema trees. For comparisons of JSON schema generation pipelines across providers, explore our breakdown on structured outputs across Claude, GPT, and Gemini.
| Capability | Decisions API | Structured Outputs (Responses) | Function Calling |
|---|---|---|---|
| Primary Model | gpt-6-luna | Various GPT models | Various GPT models |
| Return Format | Typed probabilities, choices, scores | Arbitrary JSON adhering to custom schema | Tool name and argument payload |
| Execution Speed | About 10x faster | Baseline generation latency | Baseline generation latency |
| Best Use Case | Classification, routing, filtering | Data extraction and complex synthesis | Triggering external client code |
When your architecture requires drafting explanatory copy or populating nested schema hierarchies, utilize Structured Outputs or standard model calls. If your application only requires discrete routing choices or threshold-based filters, Decisions provides lower latency and avoids output parsing overhead.
Implementation Gotchas and Migration Checklist
Before transitioning production evaluation queues to POST /v1/decisions, verify that your integration complies with the operational constraints detailed in the create decision reference.
- Target model: Ensure requests explicitly specify model as gpt-6-luna.
- Media restrictions: Audio inputs, binary file references, and file_id attributes are unsupported.
- JSON scoping: Ensure input_json content parts reside exclusively in items where role is set to user.
- System messages: System roles are accepted but are processed internally as developer messages.
- Error handling: Inspect each item in the answers array for type equal to refusal before parsing results.
- Batch optimization: Consolidate up to 400 questions per call and reuse static input blocks to leverage prompt caching.
To learn more about caching behavior and baseline costs across model families, consult our guide to prompt caching mechanics.