OpenAI made its Decisions API generally available on Thursday, October 22, an endpoint that skips the essay and hands back a number. Its developer guide says the API returns typed answers “about 10x faster than the Responses API,” the company’s general-purpose endpoint for generating text.
It runs only on gpt-6-luna, OpenAI’s cheap, fast model. Pricing is $0.10 per million uncached input tokens, and output tokens aren’t charged at all.
That last detail is the headline for anyone running AI at volume. It’s also the clearest sign yet that OpenAI sees a new product category forming, and that it was late to it.
What it actually does
A request has three parts: the model, shared evidence (text, images, JSON, or a conversation that includes tool calls and their outputs), and a list of questions. Each question is one of three types:
- Predicate: the probability, from 0 to 1, that a condition is true. Is this package dented?
- Choice: one option from a fixed list, with probabilities for each option and a separate confidence value. Billing, technical or shipping?
- Score: a rating against 2 to 10 ordered levels, returned as a probability-weighted average that can land between levels. A score of 1.1 on a three-level severity rubric means “mostly level 1, leaning up.”
The response is an answers array keyed to the names you gave each question. No prose, no reasoning, no explanation. Your application takes the number and decides what to do with it.
A single request can now hold up to 400 questions, double the 200 allowed during the public beta. The what’s-new list also adds prompt caching, native JSON input, images inside individual question instructions, hosted image URLs, conversation-history evaluation, organization usage reporting, Private Link (a private network connection that avoids the public internet) and a native hookup to OpenAI’s GPT-Live voice product.
Why output is free
Why it matters: a huge share of real-world AI use isn’t writing. It’s routing a support ticket, flagging a risky shell command, sorting a transaction or deciding whether an agent should ask a clarifying question. Doing that with a chat model means paying for words you then parse back into a label, and waiting while the model generates them.
For context, OpenAI priced GPT-6 Luna at $0.10 per million input tokens and $0.50 per million output tokens when it launched on September 22, according to Unite.AI’s summary. The Decisions endpoint keeps the input price and drops the output charge. Cached input runs $0.01 per million tokens, per the same report.
Our read: if the answer is a number, OpenAI has decided it isn’t worth billing for. That’s partly generosity and partly arithmetic. A probability is a handful of tokens at most, so OpenAI gives up very little revenue while making the price comparison with rivals look clean.
The fine print matters, though. The guide says regional processing premiums and long-context multipliers still apply, and that cache writes are charged.
OpenAI is chasing a category it didn’t start
The interesting context is outside OpenAI’s announcement. Decision models, as the trade press now calls them, didn’t start in San Francisco’s AI giants.
According to The New Stack, a startup called TypeSafe AI introduced a model named Jev and an API it calls “System One” in September. The name borrows psychologist Daniel Kahneman’s term for fast, intuitive judgment. Within weeks, AWS released an open-weight model called Strands Decider 2B that answers at the same /v1/systemone endpoint. Upstage serves its Solar Decide model through the same schema. Ollama, the popular tool for running models locally, added a System One endpoint in version 0.35.
The New Stack’s October 9 headline put it bluntly: “AWS, Upstage and Ollama agree on a decision-model API. OpenAI hasn’t signed on.” At that point, it reported, OpenAI’s version was still in limited preview with “no published schema or pricing.”
Now it has both, and they aren’t System One. OpenAI calls its yes-or-no type a “predicate,” while the System One schema has its own question format. Code written for one doesn’t drop into the other without changes.
The catch: we’ve seen this movie. OpenAI’s Chat Completions API became the de facto standard for calling language models because so many rivals cloned it. The New Stack draws the same parallel. The difference this time is that the cloning started elsewhere first. Developers who want to swap between a hosted model and a self-hosted open one already have a shared contract to write against, and it isn’t OpenAI’s.
What customers say
OpenAI’s announcement quoted several customers, as summarized by Unite.AI:
- Datadog scores the risk of agent-generated shell commands before they run, with 40x faster p95 latency (the time within which 95% of requests finish) than available frontier models at comparable accuracy.
- Sierra picks the next action in parts of live customer conversations at under 280 milliseconds p95, about 3x faster and 90% cheaper per call than its previous approach.
- Speak says time to next action in its GPT-Live integration fell from 1.4 seconds to 0.13 seconds in its testing.
- Ramp says attributing AI costs to underlying work got 4x faster and 30% cheaper than using GPT-6 Luna directly.
- Box reported roughly 5x faster routing across 30 certificate-of-insurance cases at the same accuracy as the Responses API, with lower-confidence cases sent to human reviewers.
OpenAI also said its own teams use the API, including its Communications team, which classifies press coverage by theme and scores whether it “reinforces or challenges key narratives.” So yes, there is now a model scoring how journalists write about the company that built it.
The catch: these are vendor-selected testimonials, each using the customer’s own benchmark. The Box sample was 30 cases. “Comparable accuracy” is doing a lot of work in the Datadog line. Treat these as signs of what’s possible, not guarantees.
The fine print on probabilities
The guide is admirably frank on one point. It tells developers to “use labeled examples from your application to set thresholds” and to choose them “based on the cost of false positives and false negatives.”
That’s the right advice. It’s also an admission that a 0.92 means whatever your own data says it means. A probability from a model isn’t a calibrated fact about the world. It’s the model’s estimate, and models can be confidently wrong.
The New Stack flags a sharper risk. It cites a University of Southern California researcher who found that an optimizer could flip 61.4% of 508 initially correct decisions from TypeSafe’s Jev by adding short, natural-looking text designed to push it toward a chosen wrong answer. An open model in the same study flipped at 72.6%. That’s an adversarial test, not an everyday failure rate. But decision models are built to act directly on their answers, often on text that users supplied. That’s exactly where an attacker would aim.
Other limits from the docs:
- Files, audio and item references aren’t supported, and
file_idinputs don’t work. - Questions that depend on an earlier answer need separate requests.
- For anything that needs a custom JSON object, extracted fields or a written explanation, OpenAI points you back to Structured Outputs in the Responses API.
Who should care
If you run a product that makes thousands of small judgment calls an hour, such as moderation queues, ticket routing, fraud flags or agent guardrails, this is a meaningful price and latency cut. Zero Data Retention and HIPAA use are available for eligible customers, which matters for health and finance teams.
If you’re building agents, the bigger idea is architectural. A large model plans and writes; a small, fast decision model handles the many yes-or-no gates between steps. The New Stack describes the decision model as “the if statement of an AI application.” That’s a useful way to think about it, as long as you remember an if statement normally doesn’t guess.
If you already wrote against System One, OpenAI’s endpoint is another integration rather than a drop-in replacement.
The takeaway
Our read: this is OpenAI building plumbing for the agent era, where models make thousands of tiny calls per task and latency matters more than eloquence. The free-output pricing is aggressive, but it’s priced on a product where output is nearly free to produce anyway. The more strategic question is the interface. OpenAI shipped its own schema into a market already converging on someone else’s.
What to watch:
- Whether OpenAI adds models beyond Luna, including a smaller, cheaper one.
- Whether it adopts or bridges to System One, or tries to turn its own schema into the open standard, as it did with Open Responses.
- Whether rivals match zero-cost output.
- Independent benchmarks of calibration and robustness to adversarial text, not just customer speed claims.
Image: HaeB / Wikimedia Commons, CC BY-SA 4.0
_-1.jpg){kind=link}