What Is the OpenAI Decisions API? How It Compares With TypeSafe Jev: Inputs, Outputs, Availability, Pricing and How to Choose (2026)
At DevDay 2026 OpenAI announced the Decisions API, which answers a specific set of user-defined questions with finite pre-defined answers. TypeSafe's Jev takes a similar approach. What each accepts and returns, where each stands today, what each costs, and how to choose.
1. The short answer: what the OpenAI Decisions API is
The Decisions API is a new interface OpenAI announced at DevDay 2026 on September 29, 2026. OpenAI's DevDay recap says it enables real-time decision-making by focusing Luna's intelligence on "a specific set of user-defined questions with finite pre-defined answers." Developers supply context as text or images and get back answers they can use to classify content, route requests or choose an agent's next action. On September 29, OpenAI said it was available in limited preview, with a broad release planned in the following days. In engineering terms: you define a set of questions, each with a finite set of pre-defined answers, pass text or an image as context, and get back answers your code uses to classify, route or pick an agent's next step. Whether the response carries anything beyond the answers, such as explanations or probabilities, the recap does not say. The recap text only says "Luna" and gives no model version. OpenAI introduced GPT-6 Sol and Luna on September 22, and its developer docs describe GPT-6 Luna as its most efficient model for focused, high-volume tasks. What the recap does not cover: pricing, latency figures, whether probabilities or confidence are returned, supported languages, or how much context fits in a request. As of October 4, 2026, the OpenAI developer docs index, changelog and pricing page also have no Decisions API entry yet, so wait for the official documentation for the details. It was one of the DevDay 2026 announcements; the rest (dots, GPT-6.1 Sol, the $500 Pro tier and more) are at /hub/openai-devday-2026.
2. What TypeSafe Jev is: a different company's take on the same problem
Jev is the first public System One model from TypeSafe AI, announced on September 15, 2026. TypeSafe describes System One models as a new class of model built for decisions inside software. You send a state plus a set of questions whose answer types you define, and Jev answers every question in parallel, with probabilities. There are three question types: Choice picks one option from a list, Score rates the state against ordered levels, and Noul returns the probability that a statement is true. The homepage FAQ is explicit that Jev understands language but does not generate free-form text or act as a chatbot. So, are the Decisions API and Jev the same thing? They target the same kind of problem — a decision your code can act on directly — but they are separate products from separate companies, with different published request formats, capability limits and availability. We cover Jev in depth, including TypeSafe's own list of weak spots and a worked cost example, at /hub/jev-typesafe-ai. This page focuses on the comparison.
3. Inputs: the Decisions API takes images, Jev takes text only
This is the hardest difference between the two. OpenAI's recap states that context can be provided as text or images. TypeSafe's Models page says Jev's input is text only — a string, a JSON object or an array of text values — with no image, audio or video input, and that non-text inputs should be pre-processed into text or structured fields before being sent as state. The practical effect on your architecture is direct. If the thing you are judging is itself an image (a product photo, a screenshot, an uploaded document), OpenAI says the Decisions API accepts images as context, which in principle removes the convert-to-text step; how well it does on your images is something to test with your own samples once you have access. With Jev you add a step in front: caption or OCR the image with another model first, which means one more call, more latency, more cost, and one more place for errors to creep in. If your data is already text — tickets, messages, form submissions, logs — this difference stops mattering.
4. Outputs: both answer from predefined sets; the published detail differs
What they share: answers come from a finite set defined in advance. The difference is in how much each vendor has published. TypeSafe's FAQ says Jev does not generate free-form text, so your code gets typed answers without parsing prose, and its docs state that Choice returns the selected option, a probability per option and a confidence score; Score returns a score, a probability per level and confidence; and Noul returns a single probability between 0 and 1, with no separate confidence. TypeSafe's FAQ frames uncertainty as a feature: your code sets thresholds, acting automatically when confidence is high and escalating to review when it is low. TypeSafe is equally clear that Jev guarantees the shape of its answers, not that every decision is correct — it cannot invent a category outside your list, but it can choose the wrong one. On the OpenAI side, the recap says answers come from finite pre-defined answers to user-defined questions, for classifying content, routing requests or choosing an agent's next action; it does not say whether the response carries anything else, or whether probabilities or confidence are returned. If your design depends on confidence-gated routing, do not assume the Decisions API supports it until its official documentation says so.
5. Availability: one announced as a limited preview on September 29, one open for sign-up
Per OpenAI's recap, the Decisions API opened as a limited preview on September 29, with a broad release planned in the following days; that is how OpenAI put it on the day. As of October 4, 2026, the OpenAI developer docs still have no entry for it. Whether it is enabled on your account today, and what the general-availability interface looks like, is whatever OpenAI's latest announcements and your own developer dashboard show. Jev launched in early access on September 15, with developers brought off a waitlist. The TypeSafe homepage now says Jev is available to everyone and links to account creation at console.typesafe.ai, and the site's news strip carries a September 27 item saying TypeSafe is now open to everyone. So if you need a classification or routing feature in production next week, you can sign up for Jev, create a key and try it in the Playground today. The Decisions API is a better fit for your evaluation roadmap: put it on the list and run a side-by-side once it is available to you.
6. Pricing: Jev publishes a rate; for the Decisions API, go by OpenAI
Jev's official rate is $0.042 per million input tokens ($42 per billion), with output not billed. The sample request in TypeSafe's quick start — one customer message and three questions — reports 392 input tokens. At that size, one million similar calls use about 392 million input tokens, or roughly $16.50. Your real cost depends on how long your state is and how detailed your questions are; read the usage field on your own requests before budgeting. On whether the price is temporary or subsidized, the homepage FAQ says TypeSafe can serve Jev profitably at current prices and aims to make intelligence more affordable over time. As for the Decisions API, OpenAI's DevDay recap does not give a price. We would not estimate it from the per-token rates on the Luna model page: the recap does not say the two are billed the same way, and a number derived that way could be badly off. Budget from whatever OpenAI's official pricing page lists once it does.
7. How to choose: match your workload
(1) You are judging images, or mixed image and text — evaluate the Decisions API first; Jev needs the image turned into text before it can help. (2) You are already deep in OpenAI — one developer account, one data policy, one bill — and want one fewer vendor — evaluate the Decisions API once it is broadly available. (3) You need to ship now, or need a published rate to budget against — Jev currently has the more complete public documentation: published pricing, rate limits, context length, a known-weak-spots page and a long list of cookbooks. (4) Your system decides between automatic action and human review based on confidence — Jev's docs say it returns probabilities and confidence; do not assume the same of the Decisions API until its docs say so. (5) Your data is mostly not in English — TypeSafe says English is Jev's primary training language and other languages are handled but not equally well; the recap says nothing about Decisions API language support. Test both on your own non-English samples. (6) What you actually need is a reply, a summary or a rewrite — TypeSafe says Jev does not generate free-form text, and the uses OpenAI lists for the Decisions API are classifying, routing and choosing an agent's next action. Give that job to a generative model.
8. Want to try both? A minimal side-by-side evaluation
The cheapest honest test is the same questions on the same samples, run once on each. Collect around 200 real examples from your own traffic — tickets, reviews, request logs — and label the correct answers by hand. Break your judgment into the smallest questions you can, and give each question the same set of allowed answers, with the same meaning, on both sides. Then compare three things: accuracy, especially on the error type you care about most; latency measured from the region your servers actually run in; and cost per item under each vendor's official billing. On Jev, also look at the confidence distribution: how much lower the error rate is among high-confidence answers decides how much of your traffic you can safely automate. A few things to know going in. TypeSafe's launch post gives an end-to-end response time of 70ms–500ms and says its published evals are generally run from the US West Coast, where its service is currently based, so measure from your own region and include the network round trip. TypeSafe's weak-spots page for jev-1.13 lists arithmetic, counting and date comparison; do those in code. And the Decisions API is in preview, so its interface and capabilities may change — date-stamp your results.
9. Paying for either one when your card is declined
Whichever you pick, checkout can be the first obstacle. OpenAI API usage is paid in the billing section of the OpenAI developer platform, and TypeSafe is paid in its own console. One common reason for declines at overseas API checkouts is the card's issuing country, which the acquirer reads from the first digits of the card number. A card issued outside the US can carry a Visa or Mastercard logo and still fail cross-border risk checks. A common approach is a US-issued virtual card: sign up for cocodot, top up your wallet, issue a US Visa or Mastercard virtual card, and move funds from the wallet onto the card — wallet balance and card balance are separate, and money not moved onto the card cannot be charged. At checkout, enter the card number, expiry and CVV, and use a complete address that is genuinely yours, keeping the same one for the same merchant account. cocodot's US-issued virtual cards have recorded successful charges at both OpenAI (API credit purchases) and TypeSafe, but issuer and merchant risk rules change and no card can guarantee that every charge goes through. If a charge fails twice in a row, stop and check balance, address and card status rather than retrying repeatedly. Card issuance starts at /card.
10. What cocodot does and does not offer here
First, cocodot's API relay does not include the Decisions API, any GPT-6 model (Astra, Sol, 6.1 Sol or Luna), or Jev. To use either decision API, sign up with OpenAI or TypeSafe directly; cocodot's role here is the US-issued virtual card you pay with. Second, real workflows rarely stop at a decision. Once a message is classified as a refund request, someone has to write the reply; once content is flagged as high-risk, someone has to write the review note. That part needs a generative model. cocodot's API relay is OpenAI-compatible and offers GPT-5.6 Sol, Terra and Luna, GPT-5.5, Claude, Gemini, DeepSeek, Qwen, GLM, Kimi and more, metered, with one key across models; live prices are on /pricing, and the three GPT-5.6 tiers are compared at /hub/gpt-56-sol-terra-luna-api. Decisions API facts on this page come from OpenAI's official DevDay 2026 recap and OpenAI's developer documentation; Jev facts come from typesafe.ai and docs.typesafe.ai. Written in early October 2026 — both products are moving fast, so check the official pages for the latest.
Decisions API vs Jev (every cell from OpenAI or TypeSafe official pages; "not published" means the official pages do not say, not that it does not exist)
| OpenAI Decisions API | TypeSafe Jev | |
|---|---|---|
| Announced | Sept 29, 2026, at DevDay 2026 | Sept 15, 2026, TypeSafe launch post |
| Official positioning | Focuses Luna's intelligence on a specific set of user-defined questions with finite pre-defined answers, for real-time decision-making | System One model: built for decisions inside software, does not generate free-form text |
| Input | Text or images | Text only (string / JSON / array of text); images, audio and video must be converted to text first |
| Output | Answers from each question's finite set of pre-defined answers | Typed answer + probabilities; Choice and Score also return confidence |
| Probabilities returned? | Not mentioned in the recap | Yes |
| Typical uses | Classify content, route requests, choose an agent's next step | Classify, route, score, extract, yes/no checks, guardrails |
| Availability | Limited preview from Sept 29; broad release planned within days | Homepage: available to everyone, sign up in the console |
| Price | Not given in the recap; see OpenAI's official pricing | Input $0.042 per M tokens, output free |
| Latency | Recap says "real-time decisions", no number | Launch post: 70ms–500ms end to end; TypeSafe says its published evals are generally run from the US West Coast, where its service is currently based |
| Context per request | Not published | 64k tokens; state plus the longest question ≤32k |
| Languages | Not published | English is the primary training language; other languages handled but not equally well |
| Billing | OpenAI developer account | TypeSafe console |