OpenAI's Decisions API Is Live: $0.10/M Input, 10x Faster Decisions for Your AI Agents

OpenAI shipped something yesterday that should change how you build agent control flows. The OpenAI Decisions API went generally available on October 22, 2026 — a dedicated endpoint, POST /v1/decisions, that returns structured judgments instead of chat text. No more asking a chat model "is this ticket urgent?" and regex-parsing the reply. You get a probability, a choice from your fixed list, or a rubric score. OpenAI prices it at $0.10 per 1M input tokens with zero output-token fees, and claims it's roughly 10x faster than the Responses API.

My take after reading the launch coverage: if your agents burn thousands of calls on routing, triage, and classification, this is worth a prototype this week. But two things to know before you rewire anything — the 10x speed number is OpenAI's own claim, unmeasured by anyone independent, and the endpoint runs gpt-6-luna and nothing else.

What it actually returns

Most agent "decisions" today are string-parsing hacks. You ask a chat model a yes/no question, get back a paragraph, and extract the answer. It works until a model decides to be helpful and explain itself, and your router breaks at 3 AM.

The Decisions API is OpenAI productizing that pattern. The output is the judgment, in one of three shapes:

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

Conceptually, a call looks something like this (illustrative sketch, not the verbatim schema — check the docs for exact fields):

POST /v1/decisions
{
  "question": "Route this support ticket",
  "type": "choice",
  "options": ["billing", "refunds", "escalation"],
  "input": { "subject": "...", "body": "..." }
}
// → { "decision": "refunds", "confidence": 0.91 }

Inputs can be text, images (as base64 data URLs, not hosted links), and — new in GA — native JSON. That last one matters: no more wrapping your structured data in prose and hoping the model parses it back out.

What's new in GA

The timeline: 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.
• Image instruction support — vision-based judgments.
• Prompt caching — your repeated routing instructions can hit cache at $0.01 per 1M cached tokens.
• GPT-Live integration — native hookup to the real-time voice system, so voice agents can make structured judgments mid-conversation.
• Regional inference in the US and Europe, Zero Data Retention for eligible customers, and HIPAA eligibility.
• 400 questions per request — double the beta limit. One call can triage a whole queue.

That last one is the sleeper feature. A nightly batch job scoring 400 tickets as urgency predicates becomes a single API call.

Pricing, and the fine print

$0.10 per 1M input tokens. $0.01 per 1M cached input. Output-token fees: none — the endpoint returns judgments, not generated text.

Read that last line carefully. "No output-token fees" sounds like a discount; really the bill moved entirely onto input. That's honest for what the endpoint does, but compare against your current flow. If your classification hack uses 200 input tokens and 30 output tokens on a cheap model, the win here is speed and reliability, not necessarily dollars.

Two fine-print items: cache writes are billed (warming the cache costs you; only hits get the $0.01 rate), and regional processing premiums plus long-context multipliers still apply. European inference isn't the headline price.

The speed claim — handle with care

OpenAI says roughly 10x faster than the Responses API — ~150ms versus 1.6s for a standard Luna call, per ai-tldr's reporting of OpenAI's figure. Nobody outside OpenAI has published measurements. The press repeated the number; nobody reproduced it.

Architecturally it should be fast — no token-by-token generation, just a judgment head. But "should be" isn't a latency budget. If you're re-architecting latency-sensitive flows, benchmark it on your own traffic before you commit. Don't build an SLO on a press number.

What I'd actually do

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

Building new agent control flows? Design for this endpoint, but keep the model call behind an interface. Single-model lock-in is real: if gpt-6-luna misjudges your domain, there's no fallback on this endpoint.

High-stakes decisions? HIPAA eligibility helps with compliance, but a probability from one model is still one model's opinion. Human-in-the-loop stays.

Two more things from the launch window: Perplexity launched Open Decider (pplx-decider v1.1) as a direct competitor — worth watching if you want leverage or a second opinion on judgments. And OpenAI simplified its API tiers to Build/Launch/Grow in the same announcement, so check where your usage lands.

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.

Researched from the launch coverage (webpronews, tsnmedia, pandromeda, ai-tldr) — I haven't run the endpoint myself, and where OpenAI's claims are unmeasured I've said so.