OpenAI Decisions API 2026: Build Faster, Smarter App Logic

Most of our “AI features” are really just decisions: does this ticket go to billing or support, is this upload safe, should this refund get approved automatically. We’ve been routing those small yes/no and pick-one questions through full chat completions. That means paying for generated text, waiting for it, and then parsing the answer out of prose. The OpenAI Decisions API, generally available since October 22, 2026, is built to end that habit. It arrives three weeks after a public beta and about five weeks after TypeSafe launched Jev, its dedicated decision model. If your app makes thousands of small calls per hour, this launch changes your latency budget and your bill right now.

What’s actually new with the OpenAI Decisions API

OpenAI first showed the Decisions API in limited preview at DevDay on September 29, 2026. It opened a public beta to all developers on October 6, and on October 22 it moved it to general availability. It runs on one model, gpt-6-luna, through a dedicated decisions endpoint separate from Chat Completions and the Responses API. In OpenAI’s own words, the API focuses Luna’s intelligence on “questions with bounded answers.” It accepts text, images and structured inputs, and it targets near real-time decisions inside apps and agents.

The output is the key difference from a chat call. You don’t get prose back. You get one of three structured verdicts: a probability (a yes/no predicate with a confidence value), a choice from a list of options you define up front, or a score against a rubric you supply. Launch coverage cites responses up to 10x faster than equivalent chat-style calls. Reports also say GA raised the limit from 200 to 400 questions per request, so one call can evaluate a single piece of app state against hundreds of checks in parallel.

Pricing is very low. Most reports put it at $0.10 per million uncached input tokens and $0.01 per million cached input tokens, with no charge for output tokens. Reports differ on cache-write charges since GA, so check OpenAI’s pricing guide before you build a cost model on caching.

Why it matters

• Low-latency AI app logic becomes practical inline. When a decision comes back fast enough, you can put it in the request path (routing, gating, form validation) instead of a background queue.
• No more parsing prose. Structured AI decisions mean no regex over “Sure! The category is: Billing.” You get a bounded choice or a number, and your code branches on it.
• The cost model is now about input. With no output charge, what you pay depends on how much context you send. Trim your app state and you cut your bill.
• Confidence values make human-in-the-loop easy. A probability lets you auto-approve above 0.9, auto-reject below 0.1, and send everything in between to a person. Chat output can’t give you reliable thresholds like that.
• Image input widens what you can automate. Moderation, receipt checks, damage-claim triage and “is this the right product photo” can run through the same endpoint as your text classifiers.
• OpenAI is now in the decision-model race. Developers looking for a Jev alternative now have one from the biggest platform, and price pressure on both sides is likely.

How to use it today: a Decisions API tutorial

The steps below follow the API’s documented concepts: an endpoint, a model, typed questions and three answer types. The JSON field names in the snippets are illustrative. Check the exact request schema against OpenAI’s API reference before you ship, because third-party coverage hasn’t published a canonical request body.

1. Update your SDK and set your key. Decisions has its own endpoint, so older SDK versions may lack a helper for it. Use the latest client, or call the endpoint over HTTP directly.

   pip install --upgrade openai
   export OPENAI_API_KEY="sk-..."

2. Pick one decision your app already makes with a chat call. Ticket routing is the classic first move. Write down the options as a closed list. If you can’t list the choices, it isn’t a decision; it’s generation, and it stays on Chat Completions.

3. Send a choice question. The pattern: send app state in, define the options, get one option back.

   curl https://api.openai.com/v1/decisions \
     -H "Authorization: Bearer $OPENAI_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{
       "model": "gpt-6-luna",
       "input": "Customer: I was charged twice for my March invoice and need one refunded.",
       "questions": [
         {
           "id": "route",
           "type": "choice",
           "prompt": "Which team should handle this ticket?",
           "options": ["billing", "technical_support", "sales", "account_security"]
         }
       ]
     }'

4. Batch several checks into one request. This is where the 400-question limit pays off. Score, gate and route in one call and one round trip.

   {
     "model": "gpt-6-luna",
     "input": { "ticket_text": "...", "plan": "pro", "account_age_days": 412 },
     "questions": [
       { "id": "route",   "type": "choice",      "prompt": "Which team owns this?", "options": ["billing", "technical_support", "sales"] },
       { "id": "churn",   "type": "probability", "prompt": "Is the customer at risk of churning?" },
       { "id": "refund",  "type": "probability", "prompt": "Does this request qualify for an automatic refund under a duplicate-charge policy?" },
       { "id": "tone",    "type": "score",       "prompt": "Rate customer frustration", "rubric": "1 = calm, 5 = furious" }
     ]
   }

5. Branch on the confidence, not just the answer. Treat probabilities as a policy dial. This minimal Python handler uses plain HTTP, so it works on any SDK version:

   import os, requests
   
   resp = requests.post(
       "https://api.openai.com/v1/decisions",
       headers={"Authorization": f"Bearer {os.environ['OPENAI_API_KEY']}"},
       json=payload,
       timeout=5,
   ).json()
   
   answers = {a["id"]: a for a in resp["answers"]}  # field names: verify in API reference
   
   refund_p = answers["refund"]["probability"]
   if refund_p >= 0.92:
       auto_refund(ticket)
   elif refund_p <= 0.10:
       send_policy_reply(ticket)
   else:
       queue_for_human(ticket, reason="refund_uncertain")
   
   assign_team(ticket, answers["route"]["choice"])

6. Add images where they help. For moderation or claim triage, send the image alongside text state and ask a probability question such as “Does this photo show visible damage to the package?” Keep the rubric narrow. A vague question gets a vague confidence back.

7. Shadow-test before you switch. Run the Decisions API in parallel with your current chat-based classifier for a week. Log both answers, compare agreement rates, and review the disagreements by hand. Switch only when the new path matches or beats the old one on your own data. Benchmark claims are not evidence for your workload.

8. Cache your static context. If every request repeats the same policy text or rubric, structure it to qualify for cached-input pricing, which most reports put at a tenth of the uncached rate.

How it compares: OpenAI decision model vs. Jev

TypeSafe AI launched Jev on September 15, 2026 as an early-access “System One” model. It takes application state and typed questions and returns bounded choices, ordinal scores, or yes/no probabilities with confidence. That matches the shape of OpenAI’s product, which is why the market reads Decisions as a direct response.

Feature	OpenAI Decisions API	TypeSafe Jev
Status	Generally available (Oct 22, 2026)	Early access (launched Sep 15, 2026)
Model	gpt-6-luna	jev-1.13 (32K context, per OpenRouter listing)
Answer types	Probability, choice, rubric score	Yes/no probability, bounded choice, ordinal score
Inputs	Text, images, structured data	Structured or unstructured app state
Input price	~$0.10 per million tokens (cached ~$0.01)	$42 per billion tokens (~$0.042 per million)
Output price	None	None
Latency claim	Up to 10x faster than chat-style calls	~70–500 ms per decision (vendor-reported)
Where to get it	OpenAI API; also via gateways such as Vercel and Netlify	TypeSafe; Vercel AI Gateway, OpenRouter, Zenmux

Our take: Jev is cheaper on uncached list price, and TypeSafe got there first. OpenAI’s case rests on GA status, image input, a much larger question batch, and the fact that most teams already have an OpenAI account, billing and compliance review in place. Both vendors’ speed and accuracy figures are self-reported, and neither has strong independent benchmarks yet. Run the shadow test from step 7 against both before you commit.

What’s next for OpenAI API 2026 and decision models

Watch pricing first. OpenAI is undercut on uncached input, and in this category the bill is all input, so expect a price cut or a harder push on cached-input discounts. TypeSafe will likely answer with a GA release, image support, or a larger context window. Either way, the price of a classification call is falling fast, and any routing you built on chat completions a year ago is now overpaying.

Next, watch the agent frameworks. Decision models fit naturally as the “should I call this tool” or “is this step done” check inside agent loops, where today’s agents burn tokens reasoning in prose. Expect the Agents SDK, gateway providers and orchestration libraries to add decision calls as a built-in step for guardrails and tool routing. Teams that split “decide” from “generate” in their architecture now will adopt those tools faster.

Finally, watch for independent benchmarks. The category is new, and accuracy on messy real-world data is still unproven. The first credible third-party evals comparing Luna, Jev and a well-prompted small open model will show whether dedicated decision models are a real advance or a well-packaged pricing tier.

Frequently Asked Questions

What is the OpenAI Decisions API?

It’s a dedicated OpenAI endpoint, running on gpt-6-luna, that answers bounded questions about your app’s state. It returns a probability, a choice from options you define, or a score against a rubric. It doesn’t return generated text, so it suits routing, classification, approvals and guardrails.

Is the Decisions API generally available?

Yes. OpenAI previewed it at DevDay on September 29, 2026, opened a public beta on October 6, and reached general availability on October 22, 2026.

How much does the OpenAI decision model cost?

Most reports put it at about $0.10 per million uncached input tokens and $0.01 per million cached input tokens, with no output-token charge. Reports differ on cache-write charges since GA, so confirm current rates in OpenAI’s pricing guide.

Is the Decisions API a good Jev alternative?

For most teams already on OpenAI, yes. It’s GA, it accepts images, and it handles up to 400 questions per request. Jev is cheaper on list price and was first to market. Test both on your own data before you choose.

Should I replace all my chat completion calls with Decisions?

No. Replace only the calls where the answer comes from a closed set or a number: categories, yes/no gates, scores. Anything that needs written output, like replies, summaries or code, stays on Chat Completions or the Responses API. The best setups use Decisions to choose what to do and a chat model to write the words.

Can it handle images?

Yes. The Decisions API accepts text, images and structured inputs, so it works for moderation, document checks and visual triage alongside text classification.