OpenAI opens the Decisions API for small classification and routing steps inside apps

Your app calls a large model thousands of times a day just to pick one of four queues for a support ticket, or to decide whether an agent (AI software that calls tools on its own) should carry on or ask a question. On October 22, 2026, OpenAI made the Decisions API generally available, an API (the door a program uses to call a service) built for exactly this kind of job, and says it is up to 10x faster. The way to treat that number is to run it on 30 cases where you already know the right answer, in the four steps below, and only then talk about switching.

What OpenAI says about the Decisions API

According to OpenAI, apps and agents make many small decisions inside a workflow: classify an input, choose where to send a request, choose the next action. Each one is simple, but multiplied out, latency and cost add up. The Decisions API is built on GPT-6 Luna (an OpenAI model) and focuses on questions with a bounded set of answers. The company says it gives near real-time decisions from text, images and structured data, up to 10x faster than calling GPT-6 Luna itself through the Responses API (OpenAI’s standard way to call a model).

How it works, per the post: you define a question and its allowed answers, then supply context as text, images or JSON (structured data in key–value form). The API returns one of three answer types:

• predicate: a probability from 0 to 1 that a condition is true, for example whether a product has visible damage.
• choice: one value from a list you supply, for example whether an agent should continue, retry or ask for clarification. The response also includes a probability and a confidence for each option.
• score: a rating on an ordered scale, for example how severe the damage is.

You can ask up to 400 questions per request, twice the previous limit. Pricing is $0.10 per million input tokens (the units of text a model bills by), $0.01 per million for cached input (context reused between calls), and OpenAI says there are no output-token charges. Regional processing is available in the US and EU.

Two customer examples in the post show how the company wants the number read. Box, in a quote in the post, uses it to classify business documents and route them to the next step: on 30 certificate-of-insurance cases, route selection was about 5x faster than the Responses API with the same accuracy, and lower-confidence cases go to a reviewer. Sierra says it uses it to choose the next action in live customer conversations, at under 280 ms p95 (95% of calls finish in that time or faster), about 3x faster and 90% lower cost per call than its previous approach, with no drop in customer outcomes. All of these are figures stated by OpenAI and its customers; the post does not say anyone reran them independently.

Four steps to test it on 30 cases with known answers

The example below: an online shop (an example made up for this article) picks one of four queues (delivery, returns, billing, other) for each support ticket.

1. Pick one repeated choice with a clear answer set. A good step is one where the large model only has to return a label, like the four queues above. Write out the list of answers and define each in one sentence, because that is also what you will give the Decisions API.

2. Collect 30 cases whose answers a person has confirmed. Take them from old tickets that staff already handled, and mix in a few hard ones that sit between two queues. The number 30 comes from the Box example; it is enough to see a big difference, while a small one needs more cases.

3. Run both your current method and the Decisions API on exactly those 30 cases. According to OpenAI’s developer guide, you send a POST /v1/decisions request with model gpt-6-luna, the ticket text in input and a choice question in questions. For the four queues, with a one-sentence description for each answer, the request body looks like this (the sample ticket is made up for this article; the structure follows the example in the guide):

   {
     "model": "gpt-6-luna",
     "input": "Tôi bị trừ tiền hai lần cho đơn hàng này.",
     "questions": [{
       "type": "choice",
       "name": "hang_xu_ly",
       "instructions": "Chọn hàng xử lý phù hợp nhất cho phiếu hỗ trợ này.",
       "choices": [
         { "value": "giao_hang", "description": "Giao hàng và theo dõi đơn." },
         { "value": "doi_tra", "description": "Đổi hàng, trả hàng." },
         { "value": "thanh_toan", "description": "Thanh toán, hóa đơn và hoàn tiền." },
         { "value": "khac", "description": "Yêu cầu ngoài ba nhóm trên." }
       ]
     }]
   }

   (The sample ticket reads “I was charged twice for this order”; the question asks for the best queue for the ticket; the choices are delivery and order tracking, exchanges and returns, payment, invoices and refunds, and anything outside those three.)

   The response looks like this (the guide calls it an illustrative excerpt; the label and numbers here are sample values in that shape):

   {
     "answers": [{
       "type": "choice",
       "name": "hang_xu_ly",
       "choice": "thanh_toan",
       "probabilities": [
         { "value": "giao_hang", "probability": 0.01 },
         { "value": "doi_tra", "probability": 0.02 },
         { "value": "thanh_toan", "probability": 0.95 },
         { "value": "khac", "probability": 0.02 }
       ],
       "confidence": 0.93
     }]
   }

   The choice field is the answer chosen, probabilities holds the probability of each answer, and confidence is the confidence in the answer; this is the field you take to set a threshold. The guide advises using labeled examples from your own application to set thresholds for routing, filtering or review, and choosing the threshold by the cost of false positives and false negatives. Details are in the Decisions developer guide; pricing and caching details are in the pricing and availability section of the same guide. Record three numbers for each method: cases correct, time per call (run it several times at normal hours and take the p95, the time that 19 of 20 calls meet or beat), and cost per call. Also look at the confidence the Decisions API returns for each case: if the wrong cases tend to have low confidence, set a threshold and send anything below it to a person, as Box does.

4. Write down the switching rule before you look at results. For example: switch only if cases correct are no lower than your current method and the time drops enough for you to notice in your app. Put the rule on paper before the run so you cannot tune it to the results.

When the result is not better

If the Decisions API gets fewer cases right than your current method, reopen the wrong cases: do two allowed answers overlap in meaning (“returns” and “refunds”), or is the context missing something the human handler relies on? Fix the answer definitions and rerun exactly the same 30 cases. If errors still pile up on one answer, keep your current method for that answer and switch only the rest. If cases correct are equal but the time you measure barely drops, keep your current method: OpenAI’s post mentions added capacity in several regions in Asia but says nothing specific about Vietnam, so you have to measure latency from your own server.

Sources

1. OpenAI, “Build more responsive apps with the Decisions API” (October 22, 2026) — the post introducing the Decisions API, the three answer types, pricing, processing regions and the Box and Sierra examples.
2. OpenAI, Decisions developer guide — source for the request and response shape of POST /v1/decisions, the advice on setting thresholds from confidence, and the pricing and availability section.