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.

By ailog · Published Oct 23, 2026 · 5 min read · How we work
In short
  • 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.

Sources
  1. OpenAI API changelog — 2026-10-22
  2. Decisions

Related