By ByteBot
OpenAI released the Decisions API into public beta on October 6, giving developers a dedicated endpoint that returns typed answers from a predefined set — no text generation, no JSON parsing, no output tokens. It fires at POST /v1/decisions, runs on gpt-6-luna, and OpenAI claims it answers roughly 10x faster than the Responses API at $0.10 per million input tokens with zero output charges. If you’ve been kludging classification and routing workflows together with structured outputs or JSON mode, this is worth five minutes of your time.
Three Answer Types, One Endpoint
The API accepts text or inline base64 images and returns one of three answer shapes per question in a single call:
- Predicate — a 0-to-1 probability that a condition is true. Useful for binary checks: “Is this image damaged?” returns 0.87.
- Choice — selects from your fixed list of options with a confidence score. Ideal for routing: “Which support queue?” returns
{"choice": "billing", "confidence": 0.92}. - Score — a probability-weighted rating against ordered severity levels. Good for prioritization and triage.
You can batch independent questions into a single request. Dependent questions — ones where the answer to Q1 determines Q2 — require separate API calls, which matters for your latency budget in tight agent chains.
A minimal routing request looks like this:
{
"model": "gpt-6-luna",
"input": "I need to change the delivery address for my order.",
"questions": [
{
"type": "choice",
"name": "queue",
"instructions": "Select the team responsible for the requested change.",
"choices": [
{"value": "delivery", "description": "Shipping destinations and changes"},
{"value": "account", "description": "Account profile and preferences"},
{"value": "review", "description": "Ambiguous requests requiring human review"}
]
}
]
}One edge case to handle explicitly: if the model returns type: "refusal", it declined to answer. Check for this before reading the answer fields, or your code will behave unexpectedly. Per the official Decisions API documentation, refusal handling is a first-class concern, not an afterthought.
The Pricing Argument
Zero output-token charges is the headline number. For classification workloads firing millions of times a day, the math shifts meaningfully. Luna’s standard generation pricing runs $0.10 input / $0.50 output per million tokens. At 500 input tokens and a modest 20 output tokens per request, cutting the output charge entirely saves roughly 17% before you factor in the speed advantage. At 10 million daily calls, that’s real money compounding every day.
Vercel is already routing production traffic through the endpoint — a credible signal that the performance claims hold under real load. OpenAI has not yet published independent benchmarks, so the 10x speed claim stands on vendor testimony for now. Treat it as directionally useful, not gospel.
Decisions API vs. Structured Outputs vs. Function Calling
This is the question that actually matters for developers already using the OpenAI stack:
| Scenario | Best Choice | Why |
|---|---|---|
| Pick from predefined options | Decisions API | Fast, cheap, returns probabilities |
| Fill a JSON schema or generate text | Structured Outputs | Handles custom shapes and free-form fields |
| Select a tool with arguments | Function Calling | Writes tool parameters |
| Image-based classification | Decisions API | Competitor Jev doesn’t support image input |
One common gotcha: the Decisions API does not write tool arguments. If your agent needs to route to a function and generate its parameters, you still need function calling for that step. Use Decisions as the upstream classifier, not the full router.
Limitations Worth Knowing Before You Commit
A few rough edges that matter in production:
Documentation gaps. The /v1/decisions endpoint is absent from Luna’s official endpoint support table, where only Chat Completions, Responses, and Batch are listed as supported. That’s sloppy for a public beta launch and worth watching before GA.
Image friction. Images must be inline base64 — no hosted URLs, no file IDs. That’s non-trivial overhead for production pipelines pulling images from object storage.
Accuracy isn’t guaranteed to win. At least one production benchmark found the Decisions API 2x more expensive and 5-10% less accurate than TypeSafe AI’s Jev on relevance scoring tasks. Jev lacks image support, but on pure-text classification it’s a real competitor. The InfoQ DevDay 2026 recap covers the competitive landscape in more depth. Run your own evaluation before assuming OpenAI wins by default.
No fine-tuning. For specialized domains where the general model misclassifies edge cases consistently, there’s currently no path to fine-tune. That’s a significant gap for production classification at scale.
Where This Fits in the Agentic Stack
The Decisions API is most interesting as infrastructure, not just a new endpoint. It enables a clean routing pattern: use a cheap, fast classifier to decide what to do, then only invoke expensive generation models when generation is actually required. In an agent loop running thousands of decision branches per hour, that cost difference compounds fast.
The practical architecture: Decisions API classifies intent at 10x speed and near-zero marginal cost → Luna or Sol generates the response only if needed → Astra handles multi-step complex reasoning when warranted. Keep the cheap work cheap. As Unite.ai noted, this fits into OpenAI’s broader agentic stack alongside Dots agents and the Ultrafast tier — all launched the same week at DevDay.
The API is in public beta now. OpenAI says GA is coming “in the coming weeks.” Evaluate it against your current classification setup — but benchmark against your specific domain data, not just the vendor’s numbers. If you’re routing high-volume text-only requests, Jev might still win. If you need image inputs or tight OpenAI ecosystem integration, the Decisions API is the cleaner path. For a broader developer community perspective on where this fits, the HuggingFace comparison of Decisions API vs Jev is worth reading before you commit either way.
