OpenAI announced the Decisions API at DevDay on 29 September 2026 and opened it as a public beta about a week later, with documentation and a price. You send text or images plus typed questions, and it sends back typed answers with probabilities instead of prose. That is very close to what Jev has done since mid-September. We first wrote this post when OpenAI had published almost nothing; this version is based on OpenAI’s own guide. It shows where the two products really differ, what each costs, and how to build so that you can switch later.

The short answer

If your decisions are about text, you want the lowest price per call, or you need documented limits and several ways to buy it, Jev is the safer pick today. If your decisions depend on images (screenshots, product photos, scanned forms), or you already run everything through OpenAI and want one bill and one set of data controls, try the Decisions API. Either way, compare them on your own labelled examples before you move real traffic.

What OpenAI has published

When we first wrote this post, OpenAI had shared little more than a one-line description. The public beta came with a full guide. Here is what is now documented and what is still missing:

StatusWhat we know
Documented by OpenAIPublic beta, with general availability expected “in the coming weeks”. POST /v1/decisions, or client.decisions.create in the official SDKs. One model, gpt-6-luna. Three question types: predicate, choice and score. Several independent questions per request. Input as text, or user messages with text and inline base64 images. $0.10 per 1M input tokens; output, cache reads and cache writes free. Zero data retention and HIPAA for eligible customers; data residency in the US and Europe.
Claimed, not benchmarkedTyped answers “about 10x faster” than the Responses API. Launch-day demos showed about 150 ms per decision.
Not publishedMaximum number of questions, choices or levels. Context length. Rate limits. The size of the regional and long-context surcharges. How the confidence value is calculated, and how well calibrated the probabilities are. Accuracy benchmarks.

How each one works

Left: the OpenAI Decisions API takes text or a base64 image plus several typed questions (choice, score, predicate), runs on GPT-6 Luna, and returns a typed answer with probabilities for each. Right: Jev takes one text state and several typed questions, runs a non-generative model, and returns a choice, a score and a yes/no probability together.
Almost the same request shape now. The difference is the model underneath and what it can read.

A normal chat model writes its answer word by word. If you want it to classify something, you ask for JSON, check the JSON, and retry when it’s wrong. That is slow and fiddly. Both products remove that step: you describe the questions and the allowed answers, and you get back numbers and labels your code can branch on.

The OpenAI Decisions API runs on GPT-6 Luna, OpenAI’s general model, so it brings everything Luna knows, including how to read images. OpenAI hasn’t said how the endpoint turns Luna into typed answers. What comes back is close to Jev’s shape: a predicate returns a probability; a choice returns the picked value, a probability for each option and a confidence; a score returns a probability-weighted position along your levels (starting at 0), with the same extras. A question can also come back as a refusal, which your code has to handle.

Jev is a different kind of model. It never writes text at all. It reads your input once and scores every question against it at the same time, then returns a full spread of probabilities, for example billing 0.44 · technical 0.41. That spread tells you when the model is torn between two answers, which is the signal you need to send a case to a person. What is Jev? explains this in more detail.

Side by side

OpenAI Decisions APIJev
Made byOpenAITypeSafe AI
Underlying modelgpt-6-luna (a general LLM)Jev (non-generative, built for this)
StatusPublic beta since early October 2026; GA expected “in the coming weeks”Available via TypeSafe, Vercel AI Gateway, OpenRouter, Cloudflare
EndpointPOST /v1/decisions, client.decisions.createPOST /v1/systemone, AI SDK, TypeSafe SDKs
InputText, or text plus images as inline base64 data URLs (no hosted image URLs or file ids)Text only, up to 32,000 tokens of state
Question typespredicate, choice, scorenoul (yes/no), choice (up to 255 options), score (2–10 levels)
Questions per callSeveral independent questions; limit not publishedMany, answered together
What comes backProbability (predicate); probabilities per option plus a confidence (choice, score); or a refusalAnswer plus a probability for every option; confidence for choice and score
Price$0.10 per 1M input tokens, output free; regional and long-context multipliers can apply$0.042 per 1M input tokens, output free
Speed claim“About 10x faster” than the Responses API; ~150 ms in demos70–500 ms at the model (TypeSafe)
Data controlsZDR and HIPAA for eligible customers; US and EU data residencyNo training on requests; ZDR on the direct API for enterprise, or per request through Vercel AI Gateway

Speed: comparing like with like

“10x faster than the Responses API” and “150 ms” make good headlines, but be careful about what they measure. OpenAI hasn’t published a p50 or p95, and demo figures probably don’t include your network. TypeSafe’s 70–500 ms figure for Jev is measured at the model too. In our own benchmark, Jev took about 1.7 seconds per call end to end, because the time included the trip over the internet, the Vercel gateway, and the rate limits on our account. The number your users feel is always the end-to-end one.

The useful comparison is against what you would otherwise do. If your current setup asks a chat model for JSON and takes 1–3 seconds, both products are a big step forward. If you’re choosing between the two, measure both from your own servers, on the same inputs, and compare the slowest 5% of calls as well as the average.

Cost: the maths

Now that OpenAI has published a price, the comparison is simple arithmetic. Both bill input tokens only, so cost scales with how much text you send:

Bar chart of illustrative cost per million decisions at list prices. One question per text: Jev about $17, Decisions API about $40, Luna with JSON output about $55. Three questions per text in one call: Jev about $22, Decisions API about $52, Luna with JSON about $82.
Illustrative, at list prices. Both charge only for input, so the gap is the input price: about 2.4×.
  • Input price. Jev charges $0.042 per million input tokens; the Decisions API charges $0.10. With free output on both, the Decisions API costs about 2.4× as much for the same text. That is the same input rate as an ordinary GPT-6 Luna call, minus Luna’s $0.50 per million output tokens.
  • Questions per call. Both let you ask several things about the same message (which team, how urgent, is it a refund?) in one call, so you pay for the text once. Asking each question in a separate call would multiply the bill on either product.
  • Surcharges. OpenAI says regional processing premiums and long-context input multipliers apply, but its guide doesn’t give the amounts. If you need EU data residency or send long documents, check OpenAI’s pricing page before relying on the chart.
  • Images. Jev can’t read them at all, so for picture-based decisions the fair comparison is the Decisions API against Jev plus whatever model you’d use to describe the image first.

At these prices, a million short decisions costs tens of dollars on either one, so for many teams the deciding factor will be features and accuracy, not price. Our Jev pricing calculator works out the Jev side for your own volumes.

Where OpenAI is ahead: images

This is the Decisions API’s clearest advantage. Jev reads text only, so any decision about a picture needs another model first to describe it. With the Decisions API, one call can handle things like:

  • Does this product photo show the item described in the listing, and is it damaged?
  • Which screen is this app screenshot showing? (useful for computer-using agents)
  • Is this uploaded document a receipt, an invoice or an ID?

Images must be sent inline as base64 data URLs; hosted image links and uploaded file ids are not accepted. Being part of OpenAI’s platform helps too: one bill, one set of keys, and the same data controls you already use for other OpenAI calls. If you need image input but want open weights, some of the new open decision models read images as well; see Is Jev open source?

Where Jev is ahead today

  • Lower price. $0.042 against $0.10 per million input tokens, with no regional or long-context multipliers listed.
  • Published limits. TypeSafe documents the context size (32,000 tokens of state), up to 255 options per choice and 2–10 score levels, and its rate limits. OpenAI hasn’t published these yet.
  • Tested in public. How good Jev’s probabilities are has been tested in public, including by us; see our benchmark and Jev vs Laya.
  • Not tied to one cloud. Jev runs through TypeSafe, Vercel, OpenRouter and Cloudflare, and several open models (Laya, Clef, Kev) speak the same request format, so you can move to self-hosting without rewriting your calls.

Which one should you use?

  • Choose Jev if your inputs are text, cost per call matters, you want published limits and a choice of four providers, or you may want to self-host later with an open model that speaks the same format.
  • Try the OpenAI Decisions API if your decisions depend on images, you want a single vendor and OpenAI’s data controls (US/EU residency, HIPAA), or you already run your stack on OpenAI and have a labelled test set to try it on.
  • Use both if you have mixed traffic: text messages go to Jev, and screenshots or photos go to the Decisions API, behind the same function in your code.

Whatever you choose, the model shouldn’t make the final call on anything expensive or hard to undo. Let it give a signal, and let your own code decide what to do with it.

Build so you can switch

Your app calls one decide() function. Adapters connect it to Jev, the OpenAI Decisions API (beta), or self-hosted Laya. Thresholds, fallbacks and the audit log stay in your own policy code.
Swapping the model should mean re-checking thresholds, not rewriting your app.

This kind of model is only a few weeks old, and prices and formats will keep changing. Put the model call behind one small function, so changing provider is a one-file change. Here is the idea in TypeScript, with an adapter for each:

lib/decide.ts
import { experimental_decide } from 'ai';
import OpenAI from 'openai';

// What your app asks, no matter which model answers.
export type DecisionRequest<A extends string> = {
  question: string;
  answers: Record<A, string>; // answer -> what it means
  context: string;
};

export type Decision<A extends string> = {
  answer: A;
  confidence: number | null; // null if the provider gives no score
  provider: string;
};

export type Decider = <A extends string>(req: DecisionRequest<A>) => Promise<Decision<A>>;

// Jev adapter.
export const jevDecider: Decider = async (req) => {
  const result = await experimental_decide({
    model: 'typesafe-ai/jev',
    state: req.context,
    questions: {
      pick: { type: 'choice', instructions: req.question, criteria: req.answers },
    },
  });
  const pick = result.answers.pick;
  return { answer: pick.choice, confidence: pick.probabilities?.[pick.choice] ?? null, provider: 'jev' };
};

// OpenAI adapter (Decisions API beta; needs openai >= 7.30.0).
const openai = new OpenAI();

export const openaiDecider: Decider = async <A extends string>(req: DecisionRequest<A>) => {
  const response = await openai.decisions.create({
    model: 'gpt-6-luna',
    input: req.context,
    questions: [{
      type: 'choice',
      name: 'pick',
      instructions: req.question,
      choices: Object.entries(req.answers).map(([value, description]) => ({ value, description })),
    }],
  });
  const pick = response.answers[0];
  if (pick?.type !== 'choice') throw new Error('No choice returned (refused or unexpected answer)');
  const probability = pick.probabilities.find((option) => option.value === pick.choice)?.probability;
  return { answer: pick.choice as A, confidence: probability ?? null, provider: 'openai' };
};

The decision itself then lives in your code, where you can test it:

lib/route-ticket.ts
import type { Decider } from './decide';

export async function routeTicket(text: string, decide: Decider) {
  const d = await decide({
    question: 'Which team should handle this ticket?',
    answers: {
      billing: 'Charges, invoices, refunds and plan prices',
      technical: 'Bugs, errors, outages and broken integrations',
      account: 'Login, passwords, team members and permissions',
    },
    context: text,
  });

  // Thresholds belong to you, and are tuned per provider.
  if (d.confidence === null || d.confidence < 0.8) return { action: 'review', reason: 'low confidence' };
  return { action: 'assign', team: d.answer };
}

Three things to watch. First, a confidence of 0.8 from one model does not mean the same as 0.8 from another, so tune thresholds separately for each provider. Second, the OpenAI adapter above throws when a question comes back as a refusal; catch that in your caller and send the item to review rather than dropping it. Third, the OpenAI side is a beta, so pin your SDK version and re-run your tests when it reaches general availability. The Jev AI API guide has the full Jev request format and a testing pattern that doesn’t call the model.

A test plan before you switch

Now that anyone can call the Decisions API, a fair comparison takes an afternoon:

  1. Collect 200–300 real examples from your own traffic and label them by hand. Public datasets won’t tell you how either model does on your data.
  2. Use the same wording for the question and answers on both models.
  3. Measure four things: accuracy, how often a high-confidence answer is wrong, end-to-end latency (average and slowest 5%), and cost per 1,000 decisions from your real token counts.
  4. Check the hard cases. Look at the inputs where the two models disagree. That’s where your review queue will be.
  5. Run it in shadow mode first. Log the new model’s answers next to your current setup for a week before letting it act.

That’s the method we used in our Jev vs Laya test, and we plan to run the same test on the OpenAI Decisions API. Meanwhile, you can see Jev’s answers on real examples in message triage and the other interactive tools, no code needed.

Frequently asked questions

What is the OpenAI Decisions API?

An OpenAI endpoint, POST /v1/decisions, that returns typed answers instead of text. It was announced at DevDay on 29 September 2026 in limited preview and has been a public beta since early October 2026. It runs on gpt-6-luna, supports three question types (predicate, choice and score), accepts several questions per call, and reads text and inline base64 images.

Is the OpenAI Decisions API the same as Jev?

No, but the two are now close. Both return typed answers with probabilities and accept several questions about the same input in one call. The OpenAI Decisions API runs on OpenAI's general GPT-6 Luna model and can read images. Jev is a separate non-generative model from TypeSafe AI that reads text only, is generally available, and costs less per input token.

How much does the OpenAI Decisions API cost?

OpenAI lists $0.10 per million input tokens, with no charge for output tokens, cache reads or cache writes. Regional processing premiums and long-context multipliers can apply on top. Jev lists $0.042 per million input tokens with free output, so OpenAI's input price is about 2.4 times Jev's.

Does the OpenAI Decisions API return probabilities?

Yes. A predicate answer is a probability that the statement is true. Choice and score answers return a probability for each option plus a separate confidence field. OpenAI does not say how confidence is calculated or how well the probabilities are calibrated, so check them on your own labelled data. Jev also returns a probability for every option of every question.

Is OpenRouter's Decisions endpoint the OpenAI Decisions API?

No. OpenRouter's /api/alpha/decisions and /api/v1/systemone endpoints serve Jev (typesafe/jev-1.13) and other System One models. The name is a coincidence; they are not OpenAI's product.

Sources

First published on 2 October 2026, three days after the announcement, and rewritten on 11 October 2026 from OpenAI’s Decisions API guide during the public beta. OpenAI expects general availability “in the coming weeks”, so details may still change. Cost figures are illustrative scenarios at list prices, not quotes. Jev figures come from TypeSafe’s docs and our own benchmark. This site is not affiliated with OpenAI or TypeSafe AI.