OpenAI Decisions API vs Jev: Decisions Without the Essay

TL;DR: Most of what production software asks an AI model is not an essay question — it is a yes/no check, a routing choice, or a severity score. OpenAI's Decisions API, generally available since 22 October 2026, answers those questions as typed values (a probability, a choice, or a score) on POST /v1/decisions using GPT-6 Luna, at $0.10 per million input tokens with no output charge. TypeSafe's Jev (15 September 2026) does the same job at $0.042 direct, $0.04 on tokens.bd — also with free output. For 1M decisions of 500 input tokens each, that is $50.00 on Decisions, $20.00 on Jev via tokens.bd, and $75.00 on Luna through the normal Responses API. The catch: a decision model gives you a number, not a reason — and Jev takes text only, while Decisions is OpenAI-direct only. All prices checked 26 October 2026.

Every production system that uses an LLM eventually hits the same absurdity: it asks a frontier model to write a paragraph, then parses that paragraph back into a single value it can branch on. Is this ticket a duplicate? How severe is this bug? The model writes "Based on the evidence provided, this appears to be…" and your code regexes out "billing". You pay output tokens for prose nobody reads, and every so often the parse fails and the whole request errors. Decision models cut that chain at the root: the answer is the value.

What is a decision model, and how is it different from an LLM call?#

A decision model is a model whose entire output is a typed answer your code can branch on directly — a probability that a condition is true, one value picked from a list you supplied, or a score on a rubric you defined — instead of generated text. Where a normal LLM call returns tokens you must parse, validate, and re-try when the format drifts, a decision call returns a number or an enum value with a confidence attached, in a single pass. Because nothing is generated word by word, there is no JSON to break and no preamble to strip. The trade is equally structural. A decision model cannot explain itself, write the email, or extract fields into your schema — it answers only the questions you pre-defined, over only the evidence you supplied. It is a classifier with a model's judgement, not a smaller LLM, and treating it as one is how teams misuse it.

What did OpenAI actually launch on 22 October 2026?#

OpenAI made its Decisions API generally available on 22 October 2026, after a public beta that began on 6 October and a preview at its developer day on 29 September. The endpoint is POST /v1/decisions and it runs on exactly one model, GPT-6 Luna — no decision-trained model underneath, just Luna constrained to bounded answers. A request carries shared evidence (text, images, or native JSON) plus up to 400 questions, each of one of three types: predicate returns a probability from 0 to 1 that a condition holds; choice picks one value from a list you supply and returns probabilities for every option plus a confidence; score rates the input on 2–10 ordered levels you define and returns the probability-weighted average of their indices, which can fall between levels. Since the beta, OpenAI added prompt caching, images inside individual question instructions, native JSON inputs, conversation history with tool calls, GPT-Live integration, and Private Link. Pricing is the headline: $0.10 per million non-cached input tokens, $0.01 per million cached input tokens, and no output-token charges at all.

The speed claim deserves the same treatment as any vendor number. OpenAI says Decisions answers about 10 times faster than asking Luna the same question through the Responses API, with its product lead putting typical responses at roughly 100–180 milliseconds in launch coverage. No independent benchmark has published Decisions latency yet, so treat "10x" as OpenAI's claim — but the mechanism is real: constraining the output space removes the token-by-token generation loop, where most of a short classification call's latency lives.

What is Jev, and how does it differ from Decisions?#

Jev is TypeSafe AI's decision model, launched on 15 September 2026, and it is the product that created this category — OpenAI previewed its Decisions API two weeks later. TypeSafe calls Jev a "System One" model: it reads a piece of state you supply, evaluates every question you attach to it in parallel and in isolation, and returns typed answers — Choice (one option from up to 255, with probabilities and confidence), Score (a rubric rating), or Noul (a 0-to-1 probability that a statement is true, the name short for Bernoulli) — instead of text. It is trained with what TypeSafe calls Reinforcement Learning for Calibrated Decisions, which optimises for probabilities that mean what they say across many predictions, rather than for human-preferred prose. Version jev-1.13.0 (jev-latest) carries TypeSafe's headline claim of 193.6 times faster and 444.6 times cheaper than an LLM on decision tasks — a vendor claim, not an independent measurement. What is independently checkable is the price and the shape: $0.042 per million input tokens, output free because, in TypeSafe's phrase, it is "too cheap to meter".

The differences from Decisions are practical, not philosophical. Jev accepts text only — images, audio, and video must be turned into text first — while Decisions evaluates images natively. Jev's context is 32,000 tokens (64,000-token budget per request in TypeSafe's docs) against Luna's roughly million-token window behind Decisions. Jev's vendor-reported latency is 70–500 milliseconds end to end. Jev is a standalone model callable direct or through a gateway; Decisions is an OpenAI endpoint only. The price gap is the part that survives scrutiny: $0.042 against $0.10 is 2.4 times cheaper direct, and on tokens.bd's catalog Jev lists at $0.04 per million input tokens with $0.00 output, making it 2.5 times cheaper than Decisions on input alone.

Decisions API vs Jev vs Luna: what does a million decisions cost?#

The table below is the post's original computed dataset. It prices the same workload — 1 million decisions, each on 500 input tokens, so 500 million input tokens — on every route a developer would actually consider, at list prices checked 26 October 2026 and converted at $1 = 123.59 BDT (Finnhub, 26 October 2026). The two Responses rows differ only in how much output a text call generates: 50 tokens of JSON-ish answer per decision, and a tight 10 tokens per decision. That single assumption is the whole story of this category, which is why it gets two rows instead of one. Cached-input pricing ($0.01 per million on Decisions) is left out because the workload assumes fresh evidence per decision; with a shared cached prefix the input rows would fall, but the output-charge gap would not move.

All prices checked 26 October 2026. Luna Responses figures use OpenAI list prices for prompts up to 272K tokens; tokens.bd lists Luna at $0.11/$0.55 per 1M tokens, which would put the two Responses rows at $82.50 and $60.50. Decisions pricing is OpenAI-direct only — Decisions is not listed on tokens.bd's catalog.

Three readings fall out. First, Decisions already beats a text call on price whenever the text answer runs past a handful of tokens: against the 50-token Responses shape it saves $25 on $75, a full third, and even against a disciplined 10-token answer it saves $5, or 9%. Second, Jev beats Decisions on price by a wide margin on the same workload: $20 against $50 via tokens.bd is a 60% saving, $30 kept per million decisions. Third, the per-decision numbers are small enough to mislead: $0.00005 per Decisions call, $0.00002 per Jev call via tokens.bd, $0.000021 direct. At ten million decisions those fractions become $500, $200, and $210.

On tokens.bd plans: Weekly 5X's $10 buys 500,000 Jev decisions of 500 tokens; Monthly Max's $50 buys 2.5 million. Decisions is not on tokens.bd, so its $10 figure (200,000 decisions) is hypothetical, not an offer. For a Bangladesh-based team paying in BDT, Jev through the gateway is the only decision-model route on tokens.bd.

When should you switch from a text call to a decision call?#

Switch when the application's next step is a branch, not a paragraph. The clearest candidates are already running in production somewhere: routing a support ticket to a department, scoring a bug's severity, flagging a product photo for damage, checking whether a generated answer is supported by its source, moderating a comment, re-ranking search results, or picking an agent's next step. In each case a decision call replaces parsing or a brittle classifier with a probability and a confidence it can threshold. The threshold is the part teams skip, and both vendors say the same thing about it: set it from your own labelled examples, priced by the cost of a false positive against a false negative. A predicate returning 0.92 for "visible damage" means nothing until you decide whether 0.5, 0.8, or 0.95 sends the photo to a human — and that number comes from your data, not the vendor's docs. Start with a high threshold and a human review queue, log every decision against its outcome, and lower the threshold only when the log says the model earns it.

Where those branches feed an evaluation workflow, keep a separate deadline in view: OpenAI Evals goes read-only on 31 Oct, so work through the OpenAI Evals migration checklist before then as well.

There are four places not to switch, and each maps to a real limitation. Do not use it when a human or regulator needs to know why — neither returns a rationale. Do not use it when the answer must be generated text or fields in your own schema — that is structured outputs' job. Do not use Jev when the evidence is an image or the state is larger than its 32K context — Decisions handles images natively and sits on Luna's much larger window. And do not use Decisions when you need the call to run through tokens.bd or any gateway: it is an OpenAI endpoint, so the Jev route is the gateway option today. The surviving pattern is two-tier: decision models for high-volume, low-ambiguity branches, full LLMs for everything needing words or explanations.

How do you call each one?#

A Decisions call is one HTTP request with the evidence and the questions together, and the answers come back keyed by the names you gave each question — your code branches on the value and thresholds on the confidence, sending low-confidence answers to a review queue instead of an error page. Batching is where the endpoint earns its keep: up to 400 questions can ride one request against shared evidence, so one product photo can be checked for damage, classified, and scored in a single round trip instead of three. This example, adapted from OpenAI's own docs, routes a support complaint to a department — with a fallback other option so an uncovered complaint lands in a review queue instead of erroring:

curl https://api.openai.com/v1/decisions \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "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 and refunds."},
        {"value": "technical", "description": "Product problems."},
        {"value": "shipping", "description": "Delivery and tracking."},
        {"value": "other", "description": "Everything else."}
      ]
    }]
  }'

The response is an answers array: the chosen value, probabilities for every option, and a confidence — here, billing at 0.95 probability, 0.93 confidence in OpenAI's illustrative response. For Jev, the shape is the same idea through TypeSafe's API — a state plus typed questions, currently jev-1.13.0 — and on tokens.bd Jev is listed in the catalog like any other model, so a gateway team calls it through their existing key and plan rather than opening a TypeSafe account. Check current Jev docs for exact request fields before building; the category is weeks old.

Verdict: which decision route should you pick?#

The ranking below weighs three things in order: price per million decisions, the evidence each route can take, and the billing route available to you. Price alone would crown Jev everywhere, but evidence and billing change the answer for two of the four slots — images and large context pull one workload to Decisions, and the need for generated words pulls another back to a text call. Read the list as a decision tree, not a league table: find the first slot whose constraints match your workload, and stop there. The cheapest slot is not always the right one, and the rest of this section says why each slot wins the workload it wins. If none of the four slots matches, the workload probably is not a decision workload at all — and the FAQ at the end says what to use instead.

1. Jev via tokens.bd, if you want the cheapest decisions and BDT billing. $20 per million 500-token decisions, no output charge, through the gateway you already use, on plans starting at ৳90/week. The best price in the category and the simplest billing for a Bangladesh-based team. Accept text-only evidence and a 32K context.
2. OpenAI Decisions API, if you are already on OpenAI and need images or large context. $50 per million decisions, native image inputs, JSON inputs, prompt caching, and Luna's window — at 2.5 times Jev's gateway price. The right pick when the evidence is a photo or the state is a long conversation.
3. Luna via the Responses API, only when the decision needs words attached. If the same call must also write the reply, extract fields, or call a tool, generation is the job and Decisions cannot do it — but price the output tokens honestly, because at 50 tokens per decision you are paying $75 per million where Decisions charges $50.
4. A purpose-built classifier, if the decision is narrow, stable, and high-volume enough to train for. Decision models are generalists; a trained classifier on a fixed task will usually beat them on cost and sometimes on accuracy. Its advantage is needing no training data — the answer for the long tail of decisions you have not built a classifier for yet.

The category is four weeks old, and the honest caveat is that its prices are launch prices. TypeSafe itself says its $0.042 rate's long-term sustainability is unproven, and Decisions pricing sits on Luna's list price, already cut once this year. What is durable is the shape of the win: once your application branches on a value instead of reading prose, every output token you generate is waste. Start with the decisions you already parse out of text — the savings are arithmetic, not a bet.

Decision models FAQ#

What is a decision model? A model that returns a typed answer — a probability, a choice from your list, or a score on your rubric — instead of generated text. Your code branches directly on the value, with no parsing step and no output tokens to pay for.

How much does OpenAI's Decisions API cost? $0.10 per million non-cached input tokens and $0.01 per million cached input tokens, with no output-token charges. It runs only on GPT-6 Luna via POST /v1/decisions, and it went generally available on 22 October 2026. Prices checked 26 October 2026.

How much does Jev cost? $0.042 per million input tokens direct from TypeSafe, with output free. On tokens.bd's catalog Jev lists at $0.04 per million input tokens and $0.00 output. For 1M decisions of 500 input tokens, that is $21 direct or $20 via tokens.bd, against $50 on Decisions.

Is a decision model more accurate than asking an LLM? Not by definition. Decisions constrains the same model's judgement to your answer set, which removes parse errors but not wrong answers — a confidently wrong probability is still wrong. Set thresholds from your own labelled examples and keep a human review queue for low-confidence answers.

Can I use the Decisions API through tokens.bd? No. Decisions is an OpenAI API endpoint, not a catalog model, and it is not listed on tokens.bd. The decision model available through tokens.bd today is Jev, at $0.04 per million input tokens with free output. If you need Decisions specifically, you need an OpenAI account direct.

List prices checked 26 October 2026; the maker's page is the authority for list prices, and the model catalog for prices on Tokens. BDT at $1 = 123.59 (Finnhub, 26 October 2026).

Sources: OpenAI Decisions API guide · OpenAI Decisions API general availability announcement · TypeSafe Jev pricing and limits, re-verified against primary sources · Decision AI models explained: Jev vs competitors · OpenAI launches Decisions API, Jev still ~2.4x cheaper on input · Tokens model catalog · Tokens pricing · LLM function calling guide · Structured outputs guide · Model routing guide

Relatedly, GPT-6.1 Terra: $1 Computer Use, Explained covers the computer-use work itself, while decision models judge that work.