After OpenAI Decisions API reached GA on 22 October 2026, should agent ticket routing use input_json or JSON Schema?

In an agent you route tickets to departments: some teams stuff the whole JSON into the prompt, others attach json_schema on Responses so the model emits {"department":"billing"}. Decisions is a third path: evidence via input_json, routing via a choice question, response reads the choice field directly. Treat all three APIs as one Schema and the routing layer will parse the wrong fields.

What GA on 22 October changed

As of 2026-10-24, from the changelog and the Decisions guide (marked GA, with post-beta deltas listed):

• Model: still only gpt-6-luna.
• Scale: up to questions per call rose from 200 to 400.
• Evidence: new input_json content part; shared input can carry conversation, function calls, and outputs (aligned with call_id).
• Ops: shared input can use prompt caching; per-question instructions can include images; native integration with GPT-Live.

Public beta landed 2026-10-06; GA was labeled 2026-10-22. Docs still say roughly 10× faster than Responses—good for classification, routing, and priority, not long reports or arbitrary object shapes.

Three request blocks: model, input, questions

The guide splits one decision into model, input (evidence shared by every question), and questions (type, instructions, choices or levels per question). Each question needs a unique name; answers align on that name.

Three fixed question types:

• predicate: whether a condition holds; main field probability (0 to 1).
• choice: pick one choices[].value; main field choice.
• score: ordered levels; main field score (probability-weighted mean of level indices, can sit between steps).

input can be a plain string or a message array. User messages can include text, images, and JSON; tool calls and outputs can be evidence, but Decisions only returns answers—it does not run tools for you.

input_json on user content

The ticket example in the guide puts order and ticket data in data, beside input_text on the same user message:

{
  "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 docs stress: keys like role or image_url inside data are ordinary JSON fields—they do not become a second message or fetch a remote image. Only an outer input_image part loads an image.

input_json is only supported on the user role. Do not put the same structure on developer or assistant messages.

answers are not free JSON

Example predicate response:

{
  "answers": [
    {
      "type": "predicate",
      "name": "duplicate_charge",
      "probability": 0.91
    }
  ]
}

For complaint routing, use choice with value and description on each choices entry; read answers[].choice—do not parse another nested JSON layer.

SDK samples check answer.type === "refusal" first. Treat refusals separately from normal probability or choice; do not map them to probability: 0.

With multiple questions, index by name; do not assume answers order always matches questions (though samples often match).

Choosing vs JSON Schema structured output

Guide wording: need an object against your JSON Schema (field extraction, prose) → Responses Structured Outputs; need tool calls → function calling; only need “probability / fixed options / ordered score” → Decisions.

• Route tickets to billing / technical: choice plus a little input_json, usually lower latency than json_schema.
• Extract name, address, line items: keep text.format json_schema, then validate locally with Schema validator.
• Model should call your API: function calling; Decisions tool output is only evidence—it does not fire HTTP by itself.

input_json fixes the input side so you do not stringify; it does not replace an output Schema. Do not force answers through validators you wrote for Structured Outputs—the field names and semantics do not line up.

How to check it in JSON Toolbox

Four local samples below: the first two are evidence JSON you would POST; the last two show how to read answers (still call the live API for real traffic).

{
  "evidence_ok": {
    "ticket": { "body": "Please refund the duplicate charge." },
    "order": { "charges": [49, 49] }
  },
  "evidence_stringified": "{\"ticket\":{\"body\":\"refund\"}}",
  "answer_predicate_ok": {
    "type": "predicate",
    "name": "duplicate_charge",
    "probability": 0.91
  },
  "answer_wrong_shape": {
    "department": "billing",
    "confidence": 0.91
  }
}

1. Paste all four into JSON format. The value of evidence_stringified is a string, not an object—that is why you should not stringify again.
2. Use JSON → Schema from evidence_ok to pin ticket evidence shape for repo-side checks; that is not Decisions’ request schema.
3. If you wrote a Structured Outputs schema like {"department":"string"}, answer_predicate_ok should not pass it; answer_wrong_shape should not pass as a predicate answer either.
4. Tool input contracts still go to Function Calling; free-form object notes go to structured output.

Data stays in the browser. Separate “evidence object” from typed answers before you change agent routing.

FAQ

Does input_json change the field shape in answers?

No. Question type still comes from questions[].type.

Can you use Decisions as a json_schema replacement for Structured Outputs?

No. Free-form objects use Responses; Decisions only has three answer types.

Can input_json appear in an assistant message?

No. Only user message content supports it.

How many questions can you ask in one request?

400 after GA; each question needs a unique name.

How does this split from the Claude output_config article?

That note covers Claude’s final JSON object; this one covers OpenAI’s answers array.

Summary

As of 2026-10-24, Decisions API GA is dated 2026-10-22. Endpoint POST /v1/decisions, model gpt-6-luna. Put structured evidence in input_json.data on a user message; read routing from answers—probability, choice, or score. Custom JSON Schema output stays on Responses. Next: pin the evidence object locally, parse answers by name, and do not apply Structured Outputs schemas to decision responses.

Related tools

Related articles