OpenAI takes the Decisions API to general availability: still GPT-6 Luna, now 400 questions per request

OpenAI moved the Decisions API out of public beta and into general availability on October 22, 2026. It is a dedicated endpoint at /v1/decisions: the model is still GPT-6 Luna, the input can be text, images or JSON, and the response is typed per question — a probability that a condition holds, one value picked from a list, or a score that can land between levels. OpenAI’s changelog states it plainly: “The Decisions API is now generally available with gpt-6-luna.” The same day’s developer documentation raised the per-request cap from 200 questions to 400.

Key points

• The input price did not move. Uncached input is still $0.10 per million tokens and output tokens are not charged. A Wayback snapshot of the docs from October 11, while the API was still in beta, already carried the same $0.10 figure, so general availability is not the first public price.
• What changed is quota and capability. A request now carries 1–400 questions. OpenAI’s announcement lists prompt caching, GPT-Live integration and US/EU regional processing as new this round; the docs also cover images inside question instructions, input_json, conversation history with tool calls, Private Link and an organization usage endpoint.
• The cost structure is the real change. The beta docs said there were no cache-read, cache-write or output charges. The GA docs price cache hits at $0.01 and charge cache writes at standard gpt-6-luna prompt-caching rates, while output stays free.

Background

The Decisions API appeared as a limited preview at DevDay on September 29, entered public beta in early October, and shipped today; TechCrunch’s Tim Fernholz dates the announcement to October 22, 12:00 PM PDT.

It lands in the middle of a decision-model wave. TypeSafe’s Jev claimed the position first — machines that emit a verdict instead of prose — and Amazon’s Strands Decider and Cloudflare’s Clef followed within weeks. We wrote about the category forming on October 3 and about StartLux topping a community Decision Index on October 18 with 69.12 across 173 models.

OpenAI’s move differs from those. It did not train a model for the job; it put an endpoint in front of GPT-6 Luna, which shipped in September. The interview coverage today says that out loud, which is where this gets interesting.

The facts

The interface and pricing below come from OpenAI’s developer documentation and announcement page as of October 22. The announcement page returns 403 to direct requests; the pricing lines and the feature list were checked against a Wayback capture from 19:45 UTC on October 22.

Item	Detail
Model	gpt-6-luna behind the dedicated /v1/decisions endpoint
Per request	1–400 questions (the beta cap was 200)
Question types	predicate returns a 0–1 probability; choice a selected value; score a number
Score levels	2–10 ordered levels, indices from 0, returned as a probability-weighted average that can fall between levels
Cache prefix	The reusable prefix must hold at least 1,024 tokens; question text does not count toward it
Input	Text, images (inline base64 or public HTTP/HTTPS URLs), input_json on user messages only
Not supported	file_id, files, audio, item references
History	Assistant text and refusals, function calls, custom tool calls and their outputs
Regions	United States and Europe (EEA plus Switzerland); data residency in all supported regions
Compliance	Zero Data Retention and HIPAA for eligible customers, plus Private Link
Usage	GET /v1/organization/usage/decisions returns token and request counts

Pricing splits into input, cache and output; the cache block is what moved. Beta charged nothing separately for cache reads or writes.

Line item	Rate	Source
Uncached input	$0.10 per million tokens	announcement page, developer docs
Cached input	$0.01 per million tokens	announcement page, OpenAI community post
Cache writes	Standard gpt-6-luna rates	developer docs; the announcement links the pricing guide without listing figures
Output	Not charged	announcement page, developer docs

“Standard rates” resolves against the pricing page for gpt-6-luna as we read it on October 23: on short context (up to 272K input tokens) a 30-minute cache write costs $0.125 per million tokens and a 12-hour write $0.25. The docs add that “cache-read and cache-write rates match the standard gpt-6-luna prompt caching rates,” and warn that regional processing premiums and long-context multipliers still apply. The cache block is the only change between beta and GA that makes the same request cost more: both reads and writes were free in beta, and the announcement page points to the pricing guide on the write line without printing a rate.

The output line deserves its own sentence, because the two official pages disagree on their face. The general gpt-6-luna price table lists output at $0.50 per million tokens on short context, while the Decisions guide says output tokens are not charged. The two can coexist — this endpoint returns typed answers and probabilities rather than prose — but anyone budgeting from the model price table will budget for an output charge that does not apply here. Trust the Decisions guide.

One regional detail is easy to miss: the announcement says latency work included “additional capacity in several regions in Asia,” while the docs list regional processing for the United States and Europe (EEA plus Switzerland) only. Asia got capacity, not a processing-residency commitment, and the two are not interchangeable.

Every performance figure comes from OpenAI or its customers. No third party re-tested the GA endpoint on launch day. Box reports roughly 5x faster route selection on 30 certificate-of-insurance cases at the same accuracy as the Responses API. Datadog reports 40x faster p95. Ramp reports 4x faster than GPT-6 Luna and 30% cheaper cost attribution. Sierra reports under 280 ms p95, about 3x faster at 90% lower cost per call. Speak reports time-to-next-action falling from 1.4 s to 0.13 s. The docs’ “about 10x faster than the Responses API” compares against OpenAI’s own GPT-6 Luna on the Responses endpoint, with Jev nowhere in the benchmark.

What others say

TechCrunch supplies the part OpenAI left out. The piece quotes Nikunj Handa, OpenAI’s API product lead: “But right now, it’s just plain old Luna that gets the job done.” On that reading, the decision model here is Luna plus an endpoint that returns a probability, a choice or a score — a different thing from a model trained to judge. Handa also told the outlet that latency has dropped from one to three seconds to 100, 120 and 180 milliseconds, with 60 milliseconds as the next target. That last number is a goal, not a shipped measurement.

The rankings belong to TechCrunch, because neither leaderboard’s current page was readable to us. Per that report, Jev sits seventh on the AIM System One Index and third on the Artificial Analysis Decision Index, while OpenAI lands eighth and fourteenth. The same article notes that Liquid’s D1 Ultra and Base Labs’ Elephant-1 usually lead the public boards, and that Jev tops the Pac-Man benchmark on JevMan. Artificial Analysis’s own Decision Index v1.0 write-up from October 13 puts Jev 1.13 first at 58, with GLiDE and Microsoft-Decision-1 tied at 54; “GPT-6 Luna (Decisions)” appears only in the calibration legend, with no total score.

Two independent counter-readings exist, both from the beta period and both worth reading with their dates attached. Hacker News user Topfi ran fewer than 600 calls through OpenRouter against Jev and the Decisions endpoint: 346 ms at p50, 860 ms at p95, four failed calls against zero, and an average cost 3.1 times Jev’s. In the same thread, OpenAI employee brianyu8 reproduced two examples twice each as predicate questions and got 0.99 and 0.99 in one case, 1.0 and 1.0 in the other — high confidence, the opposite of the low-confidence report. Anthus tested the underlying Luna on October 1 with 3,600 ProofWriter problems, 1,800 open-world and 1,800 closed-world: Luna’s ECE was 0.32 against 0.04 and 0.03 for Jev, and on the 2,672 questions where Luna said it was at least 99% sure, it was right 68% of the time. The author states that the test measures Luna rather than the Decisions endpoint, because OpenAI had not published API documentation at that point.

Competitors kept moving in the same week. Baseten’s research team, Base Labs, released mammoth-1 (27B) and elephant-1 (9B) on October 21; mammoth-1 ranks first of 208 models on Jev Decision Index 0.4 with 71.24, the pair score 65.9 and 65.2 on Artificial Analysis, weights are on Hugging Face, and Baseten’s hosted API is free for a week.

Our take

For teams pushing classification, routing, risk checks and guardrails into a product, the useful part of this release is the deployment checklist: regional processing, ZDR, HIPAA, Private Link and an organization usage endpoint decide whether it clears a security review. Images inside question instructions decide whether it can read screenshots and scanned documents. input_json removes a serialize-then-reparse step that used to cost tokens and accuracy. Those matter more to shipping than “10x faster.”

The economics deserve a second pass. With output unpriced and input priced per token, questions added to an existing request cost almost nothing marginal, and a shared context is paid for once — which is the real value of the 400 cap. On the other side, the cache prefix threshold is 1,024 tokens, so short requests get no discount, and cache reads and writes that were free in beta now bill. A pipeline with long shared prefixes and a poor hit rate will spend more than it did last week. Re-running the numbers against the new docs beats budgeting from headlines about “first public pricing.”

Three things deserve a discount. No third party re-tested on launch day, so the 5x, 40x and 90% figures carry customer names without published samples or methods. Artificial Analysis has no total score for the endpoint, and the community evaluations all predate GA, leaving vendor claims and secondhand rankings. And the promise that justifies the category is calibration, yet the only public calibration test measured the base model, where ECE of 0.32 sits an order of magnitude away from Jev’s 0.04 — whether the endpoint layer closes that gap is unanswered.

One judgment: what is scarce here is verifiable calibration, not a faster model. Whoever first shows on a public test set that “90% sure” means right nine times in ten earns the name decision model. Until then this is a cheap, structured interface for judgments.

How to try it

The endpoint is fixed; the request shape is what you change. Put the shared context in input, put each judgment in the questions array with a unique name, and read typed answers back by that name. The docs suggest calibrating thresholds on labeled examples first, because predicate returns the model’s own estimate rather than a guaranteed confidence.

What to watch

• Calibration numbers. Nobody has measured ECE for the GA endpoint. Anthus’s ProofWriter setup would rerun against it directly, and that is the cheapest gap to close.
• Cache bills. The announcement page lists no write rate, and reads went from free to $0.01. The first production invoices will show what long-prefix, low-hit-rate pipelines actually cost.
• Leaderboard inclusion. Artificial Analysis currently lists GPT-6 Luna (Decisions) only in its calibration legend. Whether it gets a total score decides how comparable this product line is from outside.
• 60 milliseconds. Handa’s stated next target, aimed at per-frame decisions. At that latency the use cases change shape.