A YouTube extension can ask a model whether a thumbnail contains a wide-open mouth, then hide the video. A browser experiment asks the same API which action to take next. Both use OpenAI’s Decisions API to turn a judgment into something application code can act on.

The Decisions API is an OpenAI endpoint that answers fixed-format questions about text, images, or JSON. It returns a probability, a choice from your options, or a score, and no generated prose. OpenAI introduced it at DevDay on 29 September, opened a public beta on 6 October, and made it generally available on 22 October. It runs on one model, gpt-6-luna, at a listed $0.10 per million input tokens. OpenAI’s guide says output tokens are not charged on this endpoint.

DataRoot Labs is an AI R&D company that builds and evaluates AI systems for clients. This review was first published on 9 October 2026 and updated on 19 November 2026. It draws on documentation, public code, and authors’ experiments available on that date. We have not run these projects or reproduced their measurements, and statements that something is absent describe what we found on that date.

What changed since the public beta

Scroll horizontally to explore all columns →

What changed since the public beta
 At the beta launch, 6 OctoberNow
Questions per request
Up to 200
Up to 400
Input
Text and images
Text, images, and JSON
Images
Inline base64 only
Inline or public URL; each question can carry its own
Conversation history
User messages
Messages, tool calls, and tool outputs
Prompt caching
None
Shared input of 1,024 tokens or more
Voice
Called from your own code
GPT-Live can call Decisions itself (added 15 October)

Most of these changes arrived with general availability; OpenAI’s changelog does not date all of them. The pricing statement changed with caching. The beta had no cache charges of any kind. The current guide says cache hits are discounted and cache writes are charged. The cost section below works through an example.

How the API works

A request goes to POST /v1/decisions with a model, the shared input, and a list of questions. Each question has one of three types:

  • Predicate: the estimated probability that a condition is true.
  • Choice: one selection from 2 to 255 options supplied by the developer.
  • Score: a probability-weighted average across 2 to 10 ordered rubric levels, which can fall between levels.

This is the routing example from OpenAI’s guide:

JSON
{
  "model": "gpt-6-luna",
  "input": "I was charged twice for my order.",
  "questions": [{
    "type": "choice",
    "name": "department",
    "instructions": "Which department should handle this complaint?",
    "choices": [
      {"value": "billing", "description": "Payments, invoices, and refunds."},
      {"value": "technical", "description": "Problems using the product."},
      {"value": "shipping", "description": "Delivery and tracking."},
      {"value": "other", "description": "Requests outside these categories."}
    ]
  }]
}

The answer names billing, lists a probability for every option, and adds a confidence number. A predicate answer carries a probability only.

Three details shape how applications use these answers. Any single question can come back as a refusal while the others are answered, so the code needs a path for a missing answer. The API reference lists confidence without defining it, and in OpenAI’s own example it differs from the top probability, so it should not be read as the chance of being right. Questions in one request are answered independently; the guide says a decision that depends on an earlier answer needs a separate request.

The design follows Jev, the model from TypeSafe that popularised this style of request in September. Readers of our Jev review will recognise it: define the decision, give the model relevant evidence, then let software use the answer.

Decisions or Structured Outputs

OpenAI’s guide draws the line by what the application needs back. Use Decisions for a probability, a fixed choice, or a rubric score. Use Structured Outputs when the model has to generate an object that follows your own JSON schema, such as extracted fields or a written explanation. Use function calling when the model should request a tool call with arguments.

The practical difference is speed and what you can do with the answer. A decision returns no generated text, and OpenAI presents the endpoint as much faster for that kind of question. It also returns probabilities, which lets code set a threshold. One of the projects below measured both routes on the same messages.

Ten public projects

The first six were in the October version of this article. Their repositories are unchanged since then unless noted. The last four are new.

1. Filtering the YouTube feed

Ivan Campos’s YouTube Filters combines ordinary keyword rules with optional Decisions checks. Titles can be evaluated for categories such as clickbait or artificial urgency. Image questions handle visual features, including wide-open mouths and brush-style lettering on thumbnails.

The extension lets users hide a matching video or change its thumbnail’s appearance. Keyword matches avoid paid model calls, while previous AI results can be reused. Its request builder sends selected categories as named predicate questions, adding the thumbnail when an image check requires it.

This is a useful example of a model answering a small question inside an existing interface. The reader chooses what to filter and sets the threshold. The repository provides a manually installed Chrome extension that uses the user’s own OpenAI key. It makes no accuracy claims.

2. Choosing the next browser action

The decision-luna-browse-control experiment puts a decision model in a loop: inspect the current page, choose an action, execute it, then inspect again. Its test applications cover contacts, room reservations, and support tickets in real Chromium.

The interesting part is how it checks completion. A workflow must survive saving, changing, closing, and reopening a record, followed by an independent check of stored state. A convincing final screenshot alone does not pass.

In the author’s comparison, Luna completed nine of nine workflows when it saw both the page’s structure (the DOM) and screenshots: three repetitions in each local application, with median successful times per application of roughly 41 to 47 seconds. The same recorded results show six of nine when the model saw the DOM without screenshots, and disclose that the contact tests were rerun in isolation. Nine runs on three synthetic applications make the observe, act, verify loop worth studying. They do not establish a success rate for unfamiliar commercial websites.

3. Reranking search results

Adrian Raudaschl’s RAG-Fusion experiment asks Decisions which retrieved documents help answer a query. Each request contains a pool of 50 candidate documents, with a relevance question for each. The author tries both yes/no judgments and a four-level relevance rubric.

On a sample of 200 NFCorpus queries, the rubric configuration reports 0.370 NDCG@10 for the single-query baseline. The hybrid-retrieval and query-fusion configuration adds 0.037, with a reported 95% paired-bootstrap interval of +0.014 to +0.062. NDCG@10 measures the quality of the first ten ranked results; it does not measure the accuracy of a generated answer.

The study covers one corpus and one Luna run per question type, made during the beta. Raudaschl discloses that he holds the RAG-Fusion patent, a relevant interest when reading his interpretation.

4. Routing work in n8n

The n8n Decisions community node brings the same idea into a visual workflow. Its Evaluate operation attaches answers to incoming items; Route sends each item to an output based on a decision. The package supports OpenAI alongside TypeSafe and OpenRouter, and since version 0.6 it can send one image with the text.

Its example workflow now screens out spam with a yes/no question, then chooses between billing, technical, and sales. A fuller version sends low-confidence answers and failed calls to a review queue. The adapter also handles a compatibility detail: TypeSafe-style yes/no questions become OpenAI predicates, and a refusal is preserved as a distinct result.

This is a community integration with example workflows. It is not in n8n’s verified-node registry, n8n has no built-in Decisions node, and its last release dates from 18 October. Teams trying it should inspect both the model’s routing errors and the node’s fallback behaviour.

5. Sending pull requests to the right review

Vercel’s pull-request triage tutorial supplies a PR’s title, description, changed paths, and patch text to Decisions. It asks which review track fits the change and whether callers may need migration guidance.

That is a more actionable question than asking whether a PR is “good,” and the example gives the model a needs_review option when the supplied evidence is insufficient. Application code collects the diff and prints the returned decisions; the tutorial does not approve or merge anything.

6. Comparing forecasts with prediction markets

Model vs Market compares probabilities from OpenAI Decisions, Jev, and Cloudflare Clef with Polymarket and Kalshi prices. The models receive recent news, with articles quoting betting odds removed before evaluation. A replay adds evidence article by article so readers can inspect how estimates change.

The OpenAI implementation asks a predicate question and reads the returned probability. Search is a separate component, supplied by Valyu.

As of 19 November the project does not score its predictions against resolved outcomes, so a disagreement with a market price remains only a disagreement.

7. Alerts written as a sentence

Grid Semantic Alerts lets an operator describe a condition on the Texas electricity grid in plain words. A generative model turns that sentence once into one predicate, one choice question, and a rule. Each hourly snapshot of grid data then goes to Decisions, and ordinary code applies the rule and a cooldown. A refusal counts as “not firing.”

The author replayed one week of January 2026 data. Four conventional thresholds produced 115 notifications across 92 of 168 hours; the sentence produced two. The write-up reports 168 calls, 87,358 input tokens, and a cost under one cent.

There are no labels saying which alerts were correct, and the author chose the thresholds used for comparison, so this shows fewer notifications and says nothing about accuracy. The author is frank about the limits: two compilations of the same sentence produced different rules, and the README calls a week of data “a demonstration, not an evaluation.”

8. Support triage, measured against Structured Outputs

decision-triage is the most carefully measured project here. Each support message gets one choice question over seven queues. Code routes the message automatically when the top probability passes a threshold, and sends it to a person otherwise.

The author ran the same 700 messages through Decisions and through the same model with Structured Outputs. On the 490 held-out messages, accuracy was 93.5% for Decisions and 94.3% for Structured Outputs. Median latency was 130 ms against 1,065 ms, measured from one virtual machine in Sydney at a concurrency of four. At the author’s target of 98% accuracy on automatically routed messages, Decisions could route 73% of messages without a person and Structured Outputs 83%. The raw answers are committed to the repository.

Two cautions come with it. The messages are synthetic support utterances and public SMS spam data relabelled by the author, and the data notes say absolute accuracy “overstates production accuracy.” It is also a single run from the beta period. The comparison is still the clearest public picture of the trade: similar accuracy at about an eighth of the latency, with fewer messages confident enough to route automatically.

9. Search commands for Splunk

TA-openai-decisions adds three commands to Splunk’s search language: decide for a predicate, choose for a choice, and grade for a score. Each adds fields to a log event, and the analyst filters on them with the usual where clause.

The engineering around the call is the instructive part. Answers are cached for seven days, identical events in one search are sent once, and a search stops at 1,000 requests by default. The author’s own note says five uncached events took about three seconds and that the commands are “much slower than built-in commands.” The add-on makes no claim about detection quality.

10. A robot that listens

Palmimo’s sample is the only public project we found, as of 19 November, that uses the voice integration. A small robot talks through GPT-Live, and the Live session itself calls Decisions with one choice question: which of a fixed set of actions, such as walk, wave, or stop, matches what the person just asked for.

Application code keeps control. It discards stale, duplicate, and low-confidence answers, then runs the motion through the vendor’s SDK; the architecture notes say the models never supply servo positions or executable code. The README warns that a spoken “stop” depends on the cloud and is not an emergency stop. The repository publishes no measurements.

Two voice products, in the companies’ own words

In November, OpenAI’s developer blog published accounts from two startups that use Decisions inside GPT-Live voice products. OpenAI chose the examples, and the figures are the companies’ own.

Juno asks two background questions after every turn of a call: whether anything needs logging, and which part of the history matters now. The company reports 40% fewer hand-offs from its voice agent to a text agent, without giving a sample size or method.

Weekend, which makes a spoken game, uses decisions to tell a “director” who is being addressed and when a line signals a handoff. Its team compared two ways of asking one question on twelve test lines: a yes/no predicate matched their expectation on eleven, and a two-way choice on eight. They set the threshold at 0.6 after seeing that real cues scored 0.94 and above. Twelve lines cannot establish a general rule, but the method is worth copying: try both question types and set the threshold from real examples.

What independent tests show

Most public measurements date from the beta, and each is a single run by one party. Several testers have a stake: Nexus uses Jev in its own product, and Evaboot wrote the labels for its own test. The tests also differ in task, data, and client location, so the figures below are separate examples, not a ranking.

Median latency for one text question was between about 120 and 270 ms in four tests. Each was measured from a single client location.

Scroll horizontally to explore all columns →

Research data
TestWhenMedian95th percentile
decision-triage, support routing
Mid-October, beta
130 ms
171 ms
hev, search reranking
7 October, beta
255 ms
498 ms
Nexus, eight checks
7 October, beta
268 ms
584 ms
Vikawork, intent routing
14 November
118 ms
not reported

The slowest requests tell a different story from the median: Nexus measured a 99th percentile of about 1.5 seconds. Images are slower again. Sakasegawa’s image tests measured medians of 0.31 to 0.87 seconds for one image and several seconds for four.

The speed advantage over the generative route held in both tests that measured it. decision-triage found about eight times at the median during the beta, and Vikawork found ten times on 400 routing items after general availability.

Accuracy against the same model’s generative route varied by task. Decisions was 0.8 points lower in decision-triage and 3.6 points lower on Vikawork’s routing set. In Sakasegawa’s bird-species test it reached 53% against 67% for the generative route and 93% for a model trained for the purpose; on a different image task in the same study it was ten points higher. Expect to measure this on your own task.

Against Jev, results are mixed. A lead-scoring test on 998 leads found the exact rubric level matched 46% of the time for Decisions and 71% for Jev. A guardrails board ranks Luna ninth of 49 systems and slightly above Jev. One Hacker News commenter who runs Jev in production wrote that the alternatives he tried, OpenAI’s among them, were “either too slow or not as good”; he gave no figures. Our Jev alternatives comparison covers the wider field.

Probabilities need care. Calibration means that a stated probability matches how often the answer is right. A forum test of 3,000 requests during the beta used toy prompts with known odds. Predicate answers tracked the stated odds. Choice probabilities did not: a 70/30 coin came back as 98%, and reversing the order of options moved probabilities by up to 15 points. The selected option did not change in that test, but hev’s reranking test found that reversing the candidates did change the ranking. A separate thread reports a refusal on a content-classification question that disappeared when the wording changed; no OpenAI staff member had replied by 19 November. OpenAI’s documentation gives no reasons for refusals and does not mention option order.

What it costs

The Decisions guide lists $0.10 per million uncached input tokens and says output tokens are not charged on this endpoint. The model page gives the cache rates: $0.01 for cached input and $0.125 for writing to the cache. That page also lists an output price, which applies to the model’s generative use. Requests above 272,000 input tokens are billed at twice the rate, and regional processing adds 10%.

At list price, one million decisions of 400 input tokens each cost $40.

Caching changes the arithmetic when many requests share a long prefix, such as a policy document. Take one million requests that share a 2,000-token policy and add 300 tokens each. Uncached, that is 2,300 million tokens, or $230. If every request reads the policy from the cache, it costs $20 for the cached part and $30 for the rest, $50 in total, plus a small charge each time the cache is written. That $50 is a floor. A cache write costs more than an uncached read, so a workload whose requests rarely hit the cache can cost more than the uncached $230. Only the shared input can be cached, never the questions, and the prefix must be at least 1,024 tokens and identical.

OpenAI’s guide describes Decisions as about ten times faster than the Responses API. That comparison is with OpenAI’s own generative endpoint and comes without published methodology. The two independent measurements above found eight and ten times at the median. None of these figures describes a whole workflow: for a browser task, waiting for the page may dominate, and retrieval, screenshots, repeated calls, and fallbacks all belong in the cost.

Where else it runs

The same model is reachable through several other routes. Microsoft Foundry exposes it in Azure regions. Vercel’s AI Gateway proxies the endpoint and accepts only base64 images. OpenRouter offers it through its own request shape, which follows Jev’s field names.

Framework support is early. LangChain marks its integration as beta. Pydantic AI still limits a request to 200 questions, the beta figure, and fails the whole run if one question is refused. Check how a wrapper handles refusals before adopting it, because the API’s per-question behaviour is easy to lose.

Choosing a first trial

Start with a decision your product already makes often enough to evaluate: selecting a review queue, filtering a thumbnail, or scoring a retrieved passage. Keep the present system as the baseline and replay representative inputs, including ambiguous cases and known failures.

For routing, count expensive mistakes separately from harmless ones. For ranking, inspect what reaches the first results and what disappears. For browser actions, verify the saved application state after the workflow finishes. Record full workflow cost and latency, including retries and fallbacks; median and 95th-percentile timing answer different operational questions.

A probability threshold should come from labelled examples and the consequences of a wrong answer. The tests above suggest two cheap checks to add: ask the same question as a predicate and as a choice, and reverse the order of options to see how much the probabilities move. Give refusals and uncertain results an explicit destination.

The first useful deliverable is a comparison the team can act on: which decisions improve, which inputs fail, and how much work remains around the model.

Questions about the Decisions API

Is the Decisions API still in beta?

No. It has been generally available since 22 October 2026. Some integrations, including the n8n community node and Pydantic AI, still describe it as a beta or enforce beta limits.

Does it accept images?

Yes. Images can be sent inline or as public URLs, in the shared input or attached to a single question. Audio and files are not supported.

Can it explain its answer?

No. It returns typed answers and probabilities only. For a written reason or a custom JSON object, OpenAI points to Structured Outputs on the Responses API.

Is it the same as Google’s Decisions API?

No. Google launched a separate Gemini Decisions API on 11 November 2026 with its own model and request format. The two share a purpose and a name, not a contract.

← Back to blog