Every AI agent has the same dirty secret.
It’s not the model. The model is fine. It’s the six lines of code after the model — the part where you take the AI’s nice English paragraph and try to turn it back into something your software can actually act on. A label. A route. A yes or no.
“Read this complaint and tell me which department should handle it.” The model replies: “This appears to be a billing-related issue involving a duplicate transaction, so I recommend sending it to the billing department.” Lovely. Very helpful. And completely useless to your code — which now has to regex its way through a sentence that will look slightly different every single time. (Every founder who has shipped an agent has a war story here. Mine involves the word “Refund” capitalized differently on a Tuesday.)
So on October 6, 2026, OpenAI did something I didn’t expect: it admitted this was a real problem and shipped a dedicated endpoint to kill it. The Decisions API — POST /v1/decisions, public beta — doesn’t generate text at all. It returns typed answers: probabilities, choices, scores. Numbers your code can branch on immediately.
And here’s the part that made me sit up: OpenAI says it’s about 10x faster than asking the same question through the Responses API, and it bills $0.10 per 1M input tokens with zero output charges. No output-token billing for classification work is a genuinely big deal — I’ll show you the math below.
This is the guide I wish I’d had on launch day: what shipped, how the three question types work, the real cost math, where it actually helps a startup, and the honest limitations. All verified against OpenAI’s developer docs and the launch coverage.
What OpenAI Actually Shipped
Let me get the facts straight, because there’s a lot of hype-fog around this one.
OpenAI introduced the Decisions API at DevDay on September 29, 2026, and opened it to the public as a beta on October 6, 2026 — the API changelog entry dated that day reads: “Released the Decisions API in beta with gpt-6-luna.” There’s also a full Decisions guide in the official developer docs. OpenAI says it expects general availability “in the coming weeks” — so this is early, but it’s public, and it works.
The mechanics are simple. A request has three fields: model, input (text, images, or both), and questions — a list of named questions you define. The response comes back with an answers array keyed by those names. Each question is answered independently; if one decision depends on another’s answer, that’s a second request.
Right now, exactly one model is supported: gpt-6-luna, the low-latency member of the GPT-6 family (Sol went to paid ChatGPT tiers, Luna to free tiers on October 7). There’s also a Playground in the dashboard if you want to experiment before writing code.
One catch worth knowing upfront: image inputs have to be inline base64 data URLs. Hosted image links and uploaded file IDs are refused. OpenAI is clearly optimizing for zero external network-fetch latency on its side — no waiting on your S3 bucket before the clock starts. Plan your pipelines accordingly.
The Three Question Types
This is the heart of it. Every question you ask is one of three types:
1. Predicate — “Is this condition true?”
A predicate checks one condition and returns a probability from 0 to 1. Example: given a customer photo, “does this show visible product damage?” You get back something like 0.83 — and your code decides what 0.83 means. Above 0.7, auto-approve the return. Between 0.4 and 0.7, send to human review. Below 0.4, reject. The threshold is yours, which is the whole point: the API gives you the number, your business logic owns the policy.
The docs advise calibrating thresholds with labeled examples from your own application — in other words, don’t trust a threshold you haven’t tested on your own data. Good advice, and it applies double during a beta.
2. Choice — “Which of these?”
A choice question picks one value from options you supply — and hands you the winner plus the probability for every option plus a confidence figure. “Which department handles this ticket?” with options billing / technical support / shipping / account / other. Back comes the selection, per-option probabilities, and confidence.
This is the routing workhorse. Support ticket triage, lead qualification buckets, intent classification for your chatbot — anywhere you’d previously have a prompt saying “respond with ONLY one of these labels” and then crossed your fingers. Now the constraint is structural, not a hope pinned to a system prompt.
3. Score — “How severe is this?”
A score rates input against ordered levels you define, and returns the probability-weighted average of the level indices — which can land between levels. OpenAI’s own example: level probabilities of 0.1, 0.7, 0.2 across three severity levels produce a score of 1.1 — sitting between “workaround available” and “fully blocked.” That’s more useful than a blunt integer: a 1.1 and a 1.9 are both “level 1-ish” but your escalation logic can treat them very differently.
Score questions are the sleeper hit here. Lead scoring, urgency ranking, content-risk scoring, quality grading for generated content — anywhere you currently force a model to output a number from 1-10 and then discover it loves the number 7. (They all love the number 7. I don’t know why.)
The Cost Math: Why Zero Output Tokens Matters
Okay, let’s talk money, because this is where the Decisions API quietly changes the equation for startups.
$0.10 per 1M input tokens. $0.00 for output tokens. No cache-read or cache-write surcharges. That’s the price, straight from OpenAI’s developer forum announcement. Regional processing premiums and long-context multipliers still apply — prompts above 272K tokens price at 2x input rates — but for classification workloads, that’s the headline number.
Why does zero output matter so much? Because the old pattern — ask the model, get JSON back — bills you for output tokens on every single call. And JSON is token-hungry: keys, brackets, whitespace, the little explanatory wrapper the model adds even when you beg it not to. At scale, the output side of classification calls is often where the real money goes.
Let’s make it concrete. Say your support bot triages 100,000 tickets a month, each ticket ~500 input tokens:
- Input: 100,000 × 500 tokens = 50M input tokens → at $0.10/1M = $5.00/month
- Output: $0.00. The answer is a typed value, not generated text.
Five dollars a month for 100K triage decisions. Run the same workload through the standard Responses API with a JSON-schema response, and you’re paying for output tokens on every call — short answers, sure, but at Luna’s standard output rates across 100K calls, it adds up fast. One analysis of the launch put the Decisions cost at roughly one-fifth of the equivalent classification workload on standard pricing.
And speed compounds the savings. OpenAI claims answers come back about 10x faster than the Responses API — DevDay demos reportedly put a decision near 150ms against ~1.6s for a standard Luna call. That’s OpenAI’s own number, not an independent benchmark, and nobody has published head-to-head accuracy data yet. But if it holds, the latency story matters as much as the price one: 150ms decisions can sit inside a live request path. 1.6s decisions can’t — they get shoved into background queues.
(This is the same cost-control instinct behind a lot of 2026’s infrastructure thinking — we wrote about cutting your AI API bill without hurting quality, and decision-style endpoints are now a whole category: Cloudflare’s Clef models play the same “typed answers, tiny cost” game from the edge side.)
Where This Actually Helps a Startup
Enough theory. Here’s where I’d actually deploy it in a real product:
Support triage and routing
The obvious one, and the one OpenAI leads with. Every support ticket gets a choice question (which queue?) and a score question (how urgent?). The per-option probabilities let you build a confidence gate: high confidence → auto-route; low confidence → human review. This is the pattern that turns a 12-person support team into a 3-person support team plus software.
Lead scoring that isn’t vibes
Take the inbound lead — form data, company info, first message — and run a predicate (“is this a qualified buyer?”) plus a score (“deal size potential, 0-4”). Suddenly your sales team has a ranked queue instead of a chronological one. The probability-weighted score beats the old “hot/warm/cold” buckets because you can sort on a continuous number.
Content moderation and gating
User-generated content flows through predicate checks: spam? harassment? off-topic? The probability output is exactly what moderation queues want — you set different thresholds for auto-remove, shadow-review, and allow. And with ZDR (Zero Data Retention) and HIPAA eligibility available on the endpoint, this is plausible for health-adjacent and compliance-sensitive products that couldn’t touch a standard LLM call before.
Agent tool routing
If you’re building agents — and after OpenAI’s always-on Dots agents, everyone is — your agent constantly asks “which tool do I call next?” That’s a choice question. Fast, cheap, structured. One workshop write-up I found uses exactly this pattern: a gateway asks the Decisions API which price tier a prompt needs, then routes the model call accordingly. Your agent’s router can run on Luna decisions while the heavy lifting runs on bigger models — the cheapest-tier-that-works pattern, automated.
Visual inspection
This one’s underrated because of the base64 requirement, but it’s real: product-damage checks for returns, property-condition scoring for rental listings, quality grading on a production line. Inline base64 is a hassle, but it also means no external fetch latency — the image rides along with the request. For mobile apps that already hold the photo in memory, it’s actually the natural shape.
Hands-On: Using It Well
You don’t need a special SDK to start — it’s a plain HTTPS endpoint. The shape of a call is: model, input, questions. Something like this (Python, requests):
import requests resp = requests.post( "https://api.openai.com/v1/decisions", headers={"Authorization": f"Bearer {OPENAI_API_KEY}"}, json={ "model": "gpt-6-luna", "input": "My package arrived with the box crushed and the screen cracked.", "questions": [ { "name": "department", "type": "choice", "instructions": "Which team should handle this support ticket?", "options": ["billing", "technical_support", "shipping", "account", "other"] }, { "name": "urgency", "type": "score", "instructions": "Rate the urgency of this ticket.", "levels": ["can wait", "today", "immediate", "escalate now"] } ] } ) answers = {a["name"]: a for a in resp.json()["answers"]}Three practical rules from people already experimenting with it:
- Gate on confidence, not just the answer. The choice type gives you per-option probabilities and a confidence figure — use them. High-confidence answers automate; everything else goes to a human queue. A classifier that’s honest about its uncertainty is worth ten confident-but-wrong ones.
- Calibrate thresholds on your own labeled data. OpenAI says this explicitly and they’re right. A 0.7 threshold for “spam” means something different on your user base than on anyone else’s. Take 200-500 real examples, run them through, and pick thresholds from the results — an afternoon’s work that saves months of misfires.
- Check the answer type before reading the number. Answers can come back as refusals. If your code assumes every response has a probability field, a refusal will crash it — or worse, silently misroute. Defensive parsing on a typed API. The irony is not lost on me.
The Honest Limitations
Real talk: it’s a beta, and it shows in the ways that matter for production planning.
One model. gpt-6-luna is your only option. If Luna’s judgment isn’t good enough for your task, there’s no bigger model to escalate to on this endpoint — you’re back to the Responses API with Structured Outputs, which is the fallback OpenAI itself recommends when you need explanations or your own JSON schema.
No independent accuracy data. The 10x speed claim is OpenAI’s own, measured against its own Responses API. Nobody outside OpenAI has published head-to-head accuracy or calibration numbers for /v1/decisions versus the same model through the standard API. The probabilities look calibrated — that’s the pitch — but “looks calibrated” is not a benchmark. Treat the beta period as your own evaluation window.
The competition is already here — and cheaper. TypeSafe’s Jev, a dedicated decision model that launched September 15, prices input at $0.042 per 1M tokens — about 2.4x cheaper than OpenAI’s $0.10 — though it’s still in early access. OpenAI’s edges are image input, compliance options (ZDR, HIPAA eligibility, US + EU residency), and the fact that it’s, well, OpenAI — your existing API key and billing just work.
Beta means moving parts. GA is promised “in the coming weeks,” which in platform time could mean anything. Don’t build your company’s core routing on a beta endpoint without a fallback path to Structured Outputs — which, conveniently, is the same fallback OpenAI documents.
The Decisions API isn’t a new model — it’s an admission. OpenAI looked at how developers actually use LLMs (ask a question, parse the answer, pray) and built the endpoint that workflow always wanted. The model didn’t get smarter. The interface got honest.
What I’d Build First
If I were starting from zero today, here’s my 30-day plan with this API:
Week 1: Pick your highest-volume classification pain — support triage is the default — and prototype in the Playground. Two questions: a choice for routing, a score for urgency. Run 300 historical tickets through it and compare against what your team actually did.
Week 2: Calibrate thresholds on your labeled data. Build the confidence gate: auto-route the confident ones, queue the uncertain ones for humans. Measure the agreement rate between the API and your best human triager.
Week 3: Ship it behind a feature flag with a fallback to your old path. Watch the metrics that matter: misroute rate, time-to-first-response, and cost per decision. At $0.10/1M input tokens, cost will not be the problem — accuracy will.
Week 4: Expand to the second use case — lead scoring or moderation — now that the pattern is proven. Each new question type is a config change, not a new integration.
And if you don’t have an in-house team to wire this into your product, this is exactly the kind of integration work an AI integration studio like AISquadX handles — taking a new API from Playground experiment to production routing without your roadmap catching fire.
FAQ
What is the OpenAI Decisions API?
It’s a dedicated OpenAI endpoint (POST /v1/decisions) released in public beta on October 6, 2026. Instead of generating text, it evaluates your text and/or image input against questions you define and returns typed answers: a probability (predicate), a selection from your options (choice), or a score against ordered levels (score).
How much does the Decisions API cost?
$0.10 per 1M input tokens, with no charges for output tokens, cache reads, or cache writes. Regional processing premiums and long-context multipliers (2x above 272K tokens) still apply. For classification-style workloads this works out dramatically cheaper than paying output-token rates on a standard API call.
Which models work with the Decisions API?
Only gpt-6-luna during the public beta. OpenAI hasn’t announced additional models yet. If you need a different model or want the model to write explanations, the documented alternative is the Responses API with Structured Outputs.
How is it different from Structured Outputs?
OpenAI draws a clear line: use Decisions when you want probabilities, choices, or scores — fast, typed, branchable. Use Structured Outputs when you need to fill your own JSON schema or want the model to write explanations. Use function calling when the model must request a tool call with arguments. Decisions is also roughly 10x faster than the Responses API per OpenAI’s claim.
Is the Decisions API production-ready?
It’s a public beta, with general availability expected in the coming weeks. It ships with Zero Data Retention support, HIPAA eligibility for qualifying customers, and US + EU data residency — solid compliance foundations. But there’s no independent accuracy benchmarking yet, so run your own evaluation on labeled data before making it load-bearing, and keep a Structured Outputs fallback.
The Bottom Line
The Decisions API is the least glamorous important launch of the month. No demo videos, no viral benchmarks — just a faster, cheaper, typed answer to the question every production AI system asks a thousand times a day: what do I do with this?
For startups, the math is what matters. At $0.10 per 1M input tokens and zero output charges, classification, routing, and scoring stop being a cost center you batch overnight and start being something you can afford to call inside a live request. That’s a genuine architectural shift — it moves decisions from the background queue into the hot path.
Build the prototype this week. Calibrate on your own data. Keep the fallback. And when GA lands, you’ll already know exactly what it’s worth to you — because you measured it instead of reading about it.
