OpenAI makes its Decisions API generally available: typed answers from gpt-6-luna, with no output-token charge

OpenAI moved its Decisions API out of public beta on October 22, according to its API changelog. The endpoint launched in beta on October 6 and is built for a narrow job: take text, images or structured data, ask the model a batch of questions about it, and get back typed answers rather than prose. It runs on a single model, gpt-6-luna.

OpenAI also published a post titled "Build more responsive apps with the Decisions API" on its news feed the same day, describing the product as "fast, focused, low-cost decisions for any application." That page could not be opened from our environment; this article is based on OpenAI's developer documentation.

What the endpoint does

A request to POST /v1/decisions carries an input and a list of questions. According to the Decisions guide, each question has one of three types:

• predicate: returns a probability between 0 and 1 that a condition is true (for example, "does this message report a duplicate charge?").
• choice: returns one of the values you supply, plus a probability for each option and a confidence figure. Useful for routing a ticket to a department.
• score: returns a probability-weighted position on a scale of levels you define, so a result can land between two levels. Useful for severity or priority ratings.

Any answer can come back as a refusal instead. The input can be plain text or an ordered list of messages, tool calls and tool outputs, so the endpoint can judge an agent transcript as well as a single message.

What changed with general availability

• 400 questions per request, up from 200 during the beta.
• input_json: structured data can be passed as a JSON object in a user message instead of being serialized into a string. Keys inside it are treated as data, not as message fields.
• Images in question instructions, so each question can carry its own reference image.
• Prompt caching on shared input, on by default, with an implicit breakpoint at the end of the shared input. The reusable prefix needs at least 1,024 tokens, and question text does not count toward that.

The documentation also lists Zero Data Retention and HIPAA eligibility for qualifying customers and regional processing in the United States and Europe. File inputs, audio, file_id images and item references are not supported.

Pricing

Uncached input costs $0.10 per million tokens, and the guide states that output tokens are not charged. Cache reads and writes follow gpt-6-luna's standard rates, which the pricing page lists as $0.01 per million cached input tokens and $0.125 per million for a 30-minute cache write ($0.25 for the 12-hour option). For comparison, the same model called through the Responses API bills output at $0.50 per million tokens. Regional processing premiums and long-context multipliers can apply.

Because a decision returns a number or a label rather than text, dropping the output charge matters less per call than it sounds. The real saving is structural: you stop paying for the model to write out a JSON object, or a chain of reasoning, that your code then parses for a single value.

The speed claim

OpenAI says the endpoint returns answers "about 10x faster than the Responses API." The documentation gives no latency figures, no test conditions and no rate limits, and we found no independent benchmark. Treat the 10x as a vendor claim until someone measures it on real workloads.

What it means for developers

Plenty of production LLM traffic is not generation at all: moderation checks, intent routing, triage, "is this output acceptable" gates inside agent loops. Teams typically handle these by prompting a general model to emit a label, enforcing a schema with structured outputs, then parsing. Decisions turns that pattern into a dedicated primitive, and the probabilities it returns give you something a parsed label does not: a threshold you can tune.

That changes how you write these prompts. Instead of one long prompt that asks for a JSON object with a dozen fields, you write short, single-purpose question instructions and let the shared input be cached across them. Batching up to 400 questions against the same cached context is where the cost and latency case is strongest.

The guide is explicit about the limits. If you need the model to produce an object matching your own JSON schema, it points you to Structured Outputs in the Responses API; if the model must call a tool with arguments, use function calling. Questions in one request are answered independently, so a decision that depends on an earlier answer needs a separate call. And because only gpt-6-luna is supported, you cannot trade up to a larger model for harder judgments inside this endpoint.

Before moving a classification pipeline over, run your existing labeled examples through both paths and compare accuracy, calibration of the returned probabilities, and measured latency. The pricing makes the experiment cheap; the vendor claims are the part to verify.