The October 22 general availability release is the dedicated endpoint POST /v1/decisions, and the only supported model today is gpt-6-luna. One request carries shared input and up to 400 questions; the response is an answers array keyed by the name you set on each question. Answers are not free-form JSON. They are one of three fixed shapes: predicate returns a probability from 0 to 1, choice returns one of your choice values with probabilities and confidence, and score returns a probability-weighted score over ordered levels. You may also get type: refusal, which has no probability field.
This piece is written for 24 October 2026, from the October 22 launch post and developer documentation. Two days ago we covered Claude output_config.format on Bedrock. There you supply JSON Schema and parse a text block. Decisions expects bounded options with API-fixed response fields, which fits routing, scoring, and yes/no gates, not long prose or arbitrary nested objects.
What GA on October 22 added
The launch positions Decisions for fast judgments with bounded answers: classification, routing, risk scores, and next actions in voice agents. Since public beta, OpenAI added prompt caching, native input_json, per-question images, up to 400 questions per request (200 in beta), native GPT‑Live integration, and US and EU inference residency.
The docs say GPT‑6 Luna through Decisions is about 10× faster than the same model through Responses for these tasks. Pricing lists input tokens only ($0.10 per million, $0.01 per million cached). usage may still report output_tokens; for cost math, follow the pricing page and do not multiply output tokens by chat output rates.
Three question types and answer fields
| questions.type | Use when | Main fields in answers |
|---|---|---|
predicate | A condition is true or false | probability (0–1), no confidence |
choice | Unordered labels (department, intent) | choice, probabilities[], confidence |
score | Ordered rubric levels | score as weighted index, level probabilities |
Branch on answer.type first. Documentation treats refusal separately; do not map it to probability: 0.
{
"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 and refunds."},
{"value": "technical", "description": "Product problems."}
]
}]
}
{
"answers": [{
"type": "choice",
"name": "department",
"choice": "billing",
"probabilities": [
{"value": "billing", "probability": 0.95},
{"value": "technical", "probability": 0.05}
],
"confidence": 0.95
}],
"usage": {
"input_tokens": 420,
"input_tokens_details": {
"cached_tokens": 0,
"cache_write_tokens": 0
}
}
}
Every choice value must be declared up front. Route to a human when confidence is low instead of forcing the top label.
Passing evidence with input_json
You do not need to stringify ticket and order JSON into prose. Add type: input_json to a user message content array and put the object in data. Keys inside data, even names like role or image_url, are ordinary data. They do not spawn messages or fetch images.
{
"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?"
}]
}
The answer shape is still predicate, choice, or score. input_json does not change answers. Fixed key names in data beat pasting JSON inside markdown when you want a stable cache prefix.
Aligning 400 questions by name
Send shared context once in input and fan out judgments in questions. Each name echoes in the response; index answers by name in your logs and state machines. Per-question instructions can be an array of input_text and input_image parts for candidate-specific images while input holds the shared reference.
GPT‑Live can attach type: decisions under session.triggers, run choice questions on transcript deltas, and read decision.event to drive expressions or routing.
Bill input_tokens, not output length
Decisions targets many small judgments per session: one shared input, many questions, and prompt caching on reused context (including 30-minute and 12-hour write rules described in the 12-hour cache usage piece). Keep a record like:
{
"endpoint": "decisions",
"model": "gpt-6-luna",
"question_count": 12,
"input_tokens": 9800,
"cached_tokens": 6400,
"answers_by_name": {
"department": {"type": "choice", "choice": "billing", "confidence": 0.95}
}
}
- JSON Validator — confirm
answersis an array and each item hastype. - JSONPath — e.g.
$.answers[?(@.name=='department')].confidence. - JSON Diff — see whether
inputor thechoiceslist changed.
How this splits work with Responses
The developer guide is explicit: use Decisions when you need predicate, choice, or score; use Responses structured outputs when you need your own JSON Schema for arbitrary fields or explanations; use function calling when the model must request a tool. Do not use Decisions to extract twenty contract fields. Do use a choice question for escalate vs continue.
One agent may call Decisions on the hot path and Responses on the cold path. Do not share one TypeScript type between the two response contracts.
FAQ
Can I call Decisions with gpt-6.1-sol?
Documentation lists only gpt-6-luna. Another model id returns 400. The launch emphasizes Luna speed and cost on bounded answers, not general chat.
Do keys inside input_json become message fields?
No. data is literal JSON evidence. Only recognized part types in user content, such as input_text, input_image, and input_json, are assembled into input.
Is a refusal answer a failure?
It is a policy or safety decline, not a transport error. Route to fallback or humans; do not map it to one of your choice values.
choice and score both expose probabilities. Which type?
Use choice for unordered exclusive labels. Use score when levels have order; the score field is a weighted average of level indices and can sit between levels.
usage shows output_tokens. Do I pay for them?
Pricing says Decisions bills input tokens only. Use input_tokens and cached_tokens for cost math and follow the official pricing page instead of chat output rates.
Will 400 questions blow the context window?
The cap is 400 question objects, not 400 copies of context. Shared input still counts toward tokens. Long per-question instructions crowd out evidence. Reuse short instructions, align names, and put large JSON in input_json once.
Summary
October 22 GA turns thousands of small agent branches into typed answers. Remember the endpoint, gpt-6-luna, each question name, and the predicate / choice / score / refusal branches; pass structured evidence with input_json and keep large extractions on Responses.