OpenAI’s Decisions API goes GA and prices every verdict without a single output token
On October 22, 2026, OpenAI moved its Decisions API to general availability: a GPT-6 Luna-powered endpoint that returns a probability, a choice, or a score instead of text, priced at $0.10 per million input tokens with no output tokens charged. For teams orchestrating agents, it is the first time a typed verdict gets cheap enough to live in the hot path.
October 22, 2026. OpenAI moves the Decisions API from public beta to general availability, on GPT-6 Luna only. October 22, 2026, the same day. Pricing lands: $0.10 per million input tokens, $0.01 cached, and zero output tokens charged. October 22, 2026, again. Datadog reports a 40× improvement in p95 latency for scoring the risk of agent-generated shell commands before execution. The headline: an endpoint that returns a type — probability, choice, score — rather than prose is now cheap enough to be called on every micro-decision an agent makes, in the hot path.
For an SRE or an agent architect, this is a deeper shift than a product announcement. It is the arrival of a purpose-built engine for a task nobody thought to isolate: judging.
An endpoint that answers with a type, not prose
The Decisions API does not generate text. It answers closed questions: whether a condition is met, which option to pick from a fixed list, how to score text, an image, or JSON against a rubric. The answer is a structured type, directly consumable, with no sentence to parse.
That is the difference that matters in production. An agent spends most of its tokens not on hard reasoning but on a steady drip of micro-judgments: route this, classify that, decide whether to continue. Until now, those judgments ran through a generalist model that returned text, which then had to be parsed to extract a boolean. The Decisions API removes the parsing step and, with it, a source of latency and error.
Since the beta, the endpoint has gained native GPT-Live integration, prompt caching, JSON inputs, per-question image instructions, and support for up to 400 questions per request, double the beta limit. A single request can now evaluate a whole batch of candidates or rules in one round trip.
That typed output has a direct effect on reliability. A boolean or a score cannot fail because of a malformed sentence: there is no JSON to extract from generated prose, so no costly replay when the parser breaks. For a decision loop running millions of times a day, that is a measurable reduction in errors, not a writing convenience.
Pricing built for the hot path
The pricing model is the real signal. OpenAI charges $0.10 per million input tokens, $0.01 cached, and nothing on output. That breaks with the classic model where text generation is billed per output token — precisely the most expensive, most variable part of a call.
The operational consequence is immediate: the cost of a verdict becomes predictable, bounded by the input size, and low enough to place inside a hot loop. A guardrail that checks every command before execution, a router that steers every request, a grader that scores every response — all of it can now run on every call without blowing up the bill or the latency.
OpenAI claims speeds up to 10× faster than the same Luna served through the Responses API. In production, that is not cosmetic: it is what makes hot-path placement viable at all.
What the first customers measured
The early-adopter numbers give a sense of the real, non-marketing gain. Datadog reports p95 latency 40 times lower for scoring the risk of agent-generated shell commands before running them — a textbook hot-path verdict, where every millisecond counts. Sierra runs its orchestration decisions under 280 ms p95, at 90% lower cost per call. Speak cut its time-to-next-action from 1.4 seconds to 0.13 seconds by wiring the endpoint into GPT-Live.
The three cases share something worth naming. None of them asks the AI to write. All of them ask it to decide, quickly and cheaply, between a small set of options. That is exactly the load the Decisions API was built to absorb.
Designing agents around the verdict
The availability of the Decisions API invites a rethink of how agents are built. The common reflex is to make a single call a Swiss army knife: one large prompt that reasons, generates, then decides on the way through. The split OpenAI proposes inverts the load: open reasoning stays on the Responses API, and the decision points — the router at the head of the chain, the guardrail before a sensitive action, the scorer at the tail — are delegated to a cheap, fast endpoint. In practice, that means less cumulative latency, fewer billed output tokens, and a smaller error surface: each component does one thing.
The API layer is specializing the way databases did
The movement is bigger than OpenAI. The ecosystem is seeing dedicated “decision” models emerge, and both Microsoft and AWS are pushing their own verdict primitives. The cleanest parallel is databases: half a century ago, one engine did everything; today, an analytical engine and a transactional engine coexist because their workloads have nothing in common.
The same is happening at the model layer. One engine to think — reason, generate, synthesize — and one engine to decide — route, classify, score. The two have different latency, cost, and reliability profiles, and treating them as the same call has become waste. The Decisions API is the clearest materialization of that split.
The trade-off to watch is vendor lock-in. A typed-output endpoint, wired into GPT-Live and prompt caching, locks into an ecosystem fast. For a team that values portability, the question is not whether the pattern is good — it is — but whether the abstraction deserves to be written on top, rather than marrying a proprietary endpoint.
Specialization has a cost: the Decisions API is currently locked to GPT-6 Luna, with a limit of 400 questions per request. For a team that wants to switch providers, the abstraction still has to be written itself — a layer that translates “route, classify, score” across multiple backends. That is the price of performance: speed and cost are gained at the expense of portability.
Operationally, the endpoint rewards the same discipline as any hot-path dependency. Because output is free and input is cached at $0.01 per million tokens, the levers are prompt design and batching: sending 400 tightly-scoped questions in one request costs less than a handful of chatty ones. And because a verdict now runs at every step, it deserves the same observability as any other microservice — latency percentiles, error rates, and a rollback path — rather than being hidden inside an opaque agent loop. The teams that get the most out of this are the ones that already treat their models as infrastructure: versioned, metered, and monitored, not pasted into a prompt.
Verdict
If your agents burn tokens on micro-judgments — routing, classification, guardrails, scoring — wire the Decisions API into exactly those points and measure p95 latency and per-call cost: at $0.10 per million input tokens and no output charge, a verdict becomes a hot-path primitive, not an exceptional call. If your workload needs open reasoning or generation, keep the Responses API: a decision endpoint does not think for you, it decides. The right reflex is not to pick one or the other, but to recognize they serve different functions — and to stop paying a generalist engine for judgments a specialist engine returns ten times faster.