Compare GPT-6 Luna and other decision models in one playgroundExplore the playground

Decisions API · Developer guide

What is Decisions API, and when should you use it?

A decisions API turns context into a category, a score, or a probability that your application can act on. Use it for support triage, model and tool routing, and checks against supplied evidence. This guide explains OpenAI’s direct API and how it differs from this platform’s unified interface.

Reviewed October 7, 2026 against official OpenAI documentation. Examples marked OpenAI use the direct API; this platform has its own key, model IDs, request format, and billing.

OpenAI direct API
Public beta

Model

gpt-6-luna

Endpoint

/v1/decisions

Input

Text and images

Answers

Choice, score, predicate

Choose a fixed category, rate against ordered levels, or estimate whether a condition holds. These are the direct OpenAI type names.

Availability

OpenAI Decisions API is in public beta

OpenAI’s guide documents public beta access through /v1/decisions with gpt-6-luna. For calls made through this platform, use the model directory and your account’s access to check the available options.

Checked October 7, 2026

Official API access and platform credits are managed separately.

Use cases

What can I build with Decisions API?

Start with an outcome your application can define in advance. Provide the context and criteria for the decision, then connect the answer to a known workflow.

Classify and prioritize support tickets

Ask which team owns a ticket, rate its urgency, and flag whether it needs a person. A duplicate-charge message can inform the billing queue and review priority without authorizing a refund.

See support triage

Choose a model or tool

Offer known routes such as search, database lookup, a specialist model, or human review. Your application uses the selected route to dispatch work and checks permissions before running it.

See model and tool routing

Check an answer against evidence

Provide a claim and source passages, then classify the evidence as supporting, contradicting, or insufficient. Route uncertain cases to review and evaluate the labels against human judgments.

See evidence checks

Choose the right interface

Decisions API vs Structured Outputs: what is the difference?

Both can support a classification workflow. Decisions provides dedicated answer types; Structured Outputs lets you design a JSON schema for generated content. Select by the result your application needs and test quality, latency, and cost on the same examples.

What you define

Structured Outputs

A prompt and a supported JSON schema, including required fields and allowed values.

Decisions API

Context and typed questions with conditions, choices, or ordered scoring levels.

What you receive

Structured Outputs

Generated content that follows the schema, such as extracted fields and written explanations.

Decisions API

Typed answers: a selected choice, a score, or a condition probability, with signals specific to the answer type.

What your app handles

Structured Outputs

Read the structured fields, handle refusals or incomplete responses, and validate their meaning.

Decisions API

Read the typed answers, handle refusals or failures, and apply routing or review thresholds.

Example task

Structured Outputs

Extract invoice fields and produce a written summary in one object.

Decisions API

Choose a support queue, score urgency, and evaluate a review condition.

Function calling serves another part of the workflow: the model requests a tool with arguments, and your application executes it. A decision can first choose the route; tool calls or structured generation can then complete the work.

Read the official Structured Outputs guide

Integration choices

Should I call OpenAI directly or use this platform?

Choose the service you want to integrate, then use its matching credentials and request format. This platform is independently operated and offers a shared interface for comparing several decision models.

Direct OpenAI integration

Use an OpenAI API key, POST /v1/decisions, model gpt-6-luna, and the official input and questions fields. OpenAI handles that account’s limits and billing.

This platform’s unified API

Use a platform API key and POST /v1/systemone with model, state, and a questions map. For Luna, the model ID is openai/gpt-6-luna-decisions. Other compatible models use the same envelope.

Different request limits and type names

This platform accepts 1–8 questions and a complete JSON body up to 32 KiB. Its yes-or-no question type is noul; OpenAI’s direct type is predicate. Use the documentation for the endpoint you call.

Separate accounts and charges

Calls through this platform consume platform credits. Direct OpenAI calls are billed to your OpenAI account. A platform credit purchase does not change your OpenAI balance or account limits.

Question types

How do I choose between Choice, Score, and Predicate?

Define one clear judgment per question. Use labels for categories, levels for priorities, and a condition for a yes-or-no check.

Choice

Pick from distinct categories

Example: billing, technical, account, or other. Explain each option and provide an appropriate fallback for requests outside the known categories.

Score

Rate against ordered levels

Example: routine, urgent, or critical. Describe what earns each level. The returned score can fall between levels, so decide how your application maps it to priority.

Predicate / Noul

Evaluate one condition

Example: does this case need human review? Use predicate with the direct OpenAI API or noul with this platform, then test a threshold against labeled cases.

From prototype to integration

How do I add a decision to an existing application?

Keep the first workflow small enough to inspect. Use the same inputs and criteria in your evaluation and backend integration.

01

Name the outcome

Pick a repeated decision such as the support queue. Define labels, review conditions, and what should happen when evidence is insufficient.

02

Provide the evidence

Include the customer message, relevant rules, and records needed to judge it. Leave unrelated conversation out of the request.

03

Evaluate the answer

Run clear, ambiguous, and unusual examples. Inspect the returned answer and compare it with the expected result.

04

Connect the action

Map the result to a known queue or tool. Add failure handling and a review path, then monitor errors, usage, and review volume.

Direct OpenAI request

What does a Decisions API request look like?

Send this JSON body to https://api.openai.com/v1/decisions with an OpenAI Bearer token. It asks for a support team using a choice question. The response excerpt is illustrative, not a measured result.

This text example uses OpenAI’s input and questions array. For this platform, use state and a questions map as described in our API docs.

OpenAI request body
{
  "model": "gpt-6-luna",
  "input": "My subscription was billed twice.",
  "questions": [{
    "type": "choice",
    "name": "team",
    "instructions": "Select the support team.",
    "choices": [
      {"value": "billing", "description": "Payment issues"},
      {"value": "technical", "description": "Product issues"},
      {"value": "other", "description": "Other requests"}
    ]
  }]
}
Illustrative answer excerpt
{
  "answers": [{
    "type": "choice",
    "name": "team",
    "choice": "billing",
    "confidence": 0.94
  }]
}

Check the answer type before using it; OpenAI can return a refusal. The shown confidence is not a measured accuracy rate. Keep credentials on your server.

Read this platform’s API documentation

Evaluate your own use case

How do I know whether a decision model is good enough?

Use a held-out set with expected answers. Compare models on the same cases and record both the automated outcomes and the work sent to reviewers.

Measure the mistakes

Track which labels are confused and whether important cases are missed. Include ambiguous inputs and cases outside your normal categories.

Estimate daily cost

Run a representative sample. Divide credits used by completed requests, multiply by expected daily volume, and include retries. Check current credit-pack prices before budgeting.

Set a review threshold

Compare score bands with observed correctness. Choose thresholds based on error costs and available reviewer capacity, then check them again as inputs change.

Measure delays and failures

Record response-time percentiles, failed requests, and rate-limit behavior. Set a fallback route so a timeout does not leave the workflow without a next step.

Common questions

Practical questions about Decisions API

Is OpenAI Decisions API available now?+

OpenAI’s official guide lists Decisions API as a public beta with gpt-6-luna as of October 7, 2026. Direct API usage follows OpenAI account limits. Through this platform, check the current model directory and your account access.

How do I estimate the cost of 10,000 requests a day?+

Measure the average usage of representative requests, multiply it by 10,000, and account for retries and changing input lengths. For this platform, use actual credits consumed and the current pricing page. For direct OpenAI usage, use OpenAI’s current rate card and billing records.

Can I treat confidence as the chance a decision is correct?+

Do not assume that. Condition probability and confidence have different meanings, and a model signal does not establish measured accuracy on your data. Compare the signal with known outcomes and set thresholds from that evaluation.

Can I copy the OpenAI example into the platform API?+

Use the documentation for your chosen endpoint. The direct OpenAI example uses input and a questions array. This platform uses state and a questions map, different model IDs, and a platform API key. The API documentation includes platform request and response examples.

Test a decision from your own workflow

Bring one support ticket, routing question, or evidence check to the playground. Compare results before connecting the chosen model to your backend.

Open the playground