OpenAI Decisions API Goes Live: $0.10/M Input, 10x Faster Calls — Worth Rewiring Your Agents?

Nothing here is sponsored — no affiliate links on this page. Every link goes to official docs or the launch reporting we cite.

The OpenAI Decisions API went generally available on October 22, 2026, and it's the most interesting API launch for agent builders this year. One endpoint — POST /v1/decisions — that returns structured judgments instead of chat text: a probability, a choice from your fixed list, or a rubric score. OpenAI says it's roughly 10x faster than the Responses API, charges $0.10 per 1M input tokens with zero output-token fees, and runs exclusively on gpt-6-luna. We dug through the launch reporting to separate the real deal from the marketing. Here's what's new in GA, the fine print, and whether it earns a place in your stack.

What the Decisions API actually does

Most agent "decisions" today are held together with string parsing. You ask a chat model "is this ticket urgent?", get back a paragraph, and regex out a yes. It works until it doesn't — a slightly different phrasing, a model that decides to be helpful and explain itself, and your router breaks at 3 AM.

The Decisions API is OpenAI admitting that pattern and productizing it. No chat text. The output is the judgment, in one of three shapes:

• Predicate: a 0–1 probability. "Is this support ticket urgent?" → 0.87. Set your own threshold.
• Choice: picks from your fixed list and reports its confidence. "Route this to: billing, refunds, escalation." Your list, not the model's improvisation.
• Score: grades against your ordered rubric and returns a probability-weighted average. Think quality scoring, lead scoring, content moderation tiers.

That's the whole pitch. The calls your app makes over and over — classification, routing, prioritization — minus the prompt engineering, minus the output parsing.

What's new in GA (beta → live)

The timeline: a DevDay preview in late September, public beta on October 6, GA on October 22. GA added the pieces that make it actually usable:

• Native JSON input. Feed structured data straight in instead of wrapping your JSON in prose and hoping the model parses it back out. Small change, big reliability win.
• Image instruction support. Text and images both go in — images as base64 data URLs, not hosted links, per the launch reporting.
• Prompt caching. Your routing instructions repeat every call; now the repeated prefix can hit the cache at $0.01 per 1M cached tokens.
• GPT-Live integration. Native hookup to OpenAI's real-time voice system — voice agents can now make structured judgments mid-conversation.
• Regional inference (US and Europe). For the latency- and compliance-conscious.
• Zero Data Retention for eligible customers, and HIPAA eligibility — the enterprise checkboxes, ticked.
• 400 questions per request — double the beta limit. Batch a whole queue's triage into one call.

The pricing, and the fine print

$0.10 per 1M input tokens. $0.01 per 1M cached input tokens. Output-token fees: none.

Pause on that last line. "No output-token fees" sounds like a discount — really, the bill just moved entirely onto input. That's honest pricing for what the endpoint does (it returns judgments, not generated text), but compare it against your current flow before celebrating. If your classification hack uses 200 input tokens and 30 output tokens on a cheap model, run the math in our AI API Cost Calculator before you migrate. The win here is speed and reliability, not necessarily dollars.

Two pieces of fine print worth your attention:

• Cache writes are billed. Warming the cache costs you; only the hits get the $0.01 rate. The first call in a session pays full price.
• Premiums and multipliers still apply. Regional processing premiums and long-context multipliers don't vanish on this endpoint. European inference isn't the headline price.

The speed claim — read this before you celebrate

OpenAI says roughly 10x faster than the Responses API. The concrete number floating around the launch coverage: ~150ms versus 1.6s for a standard Luna call, per ai-tldr's reporting of OpenAI's figure.

Here's the thing: nobody outside OpenAI has published measurements. The press repeated the number; nobody reproduced it. Vendor figures in launch-week reporting are marketing until proven otherwise.

That said, the architecture plausibly favors speed. No token-by-token generation, no chat formatting overhead — just a judgment head on top of the model. It should be fast. But "should be" isn't a latency budget. If you're re-architecting latency-sensitive flows around this endpoint, measure it yourself on your own traffic before you commit. Don't build an SLO on a press number.

What it's actually for

Forget the hype framing. The use case is the boring, repetitive calls your system already makes: support-ticket routing, content classification, task prioritization, and agent control-flow branches — the "should the agent escalate or keep going?" decision that currently costs you a full chat completion and a parser.

The 400-questions-per-request cap is the sleeper feature here. One call can score an entire queue: 400 tickets, each as a 0–1 urgency predicate, in a single request. If you're running nightly batch triage today as hundreds of chat calls, this is the shape of API you were waiting for.

And yes — this landed in the same week OpenAI killed 12 legacy model APIs. If you're already touching your OpenAI integration this week, it's a natural moment to look at this too.

Three reasons to pause

• Single-model lock-in. gpt-6-luna is the only model on this endpoint. If Luna misjudges your domain — and every model has domains where it's sloppy — there's no fallback model on the same endpoint. You're back to the Responses API with your old parsing hacks. One model, one opinion.
• There's already a rival. Perplexity launched Open Decider (pplx-decider v1.1) as a direct competitor in the structured-decisions space. Early days, but it gives you leverage — and a second opinion on judgments if you run both.
• Check your tier. OpenAI also simplified its API tiers to Build/Launch/Grow around the same announcement. Pricing access and rate limits may have shifted under you — verify where your usage lands before you plan spend on the new endpoint.

What we'd actually do

Already doing classification-via-chat? Prototype the swap on your highest-volume, lowest-stakes routing call this week. Measure the latency on your own traffic. Don't trust the 10x — verify it, then decide.

Building new agent control flows? Design for this endpoint, but keep the model call behind an interface. That way Perplexity's Open Decider — or a Responses-API fallback — can slot in without a rewrite when you need it.

High-stakes decisions (medical, legal, financial approvals)? HIPAA eligibility helps with compliance, but a probability from one model is still one model's opinion. Human-in-the-loop stays, regardless of the endpoint.

The bottom line: this is the first OpenAI API that treats "decide" as a first-class operation instead of a chat trick. That's genuinely useful. Just don't let launch-week numbers do your capacity planning for you.

FAQ