OpenAI Decisions API vs Jev, field by field

OpenAI Decisions API vs TypeSafe Jev, now that both contracts are public. Question types, confidence, refusals, images, limits, data terms and a 2.4x price gap.

Published by WorkerKit. Updated 2026-10-06.

OpenAI's Decisions API and TypeSafe's Jev now both publish a full contract, and they are closer than their names suggest: each takes shared evidence and a list of typed questions, and returns a probability, a pick or a score per question instead of prose. When this comparison first ran on September 29, OpenAI had announced Decisions as a limited preview with no request schema, response fields or price to compare. On October 6 it opened a public beta with a guide, an API reference and a rate, so the open questions this page used to list now have answers. What neither vendor publishes is a shared benchmark, so the comparison covers the contracts and the price, then hands you the test.

OpenAI Decisions API: the public beta explained covers the launch itself and what changes when a WorkerKit worker uses it.

Decisions API vs Jev at a glance

OpenAI's sources are the Decisions guide, the API reference, the gpt-6-luna model page and its data controls. TypeSafe's are its models page, API schema, confidence page and legal page. Where a cell says a vendor does not publish something, that is a statement about the documents, not a claim that the feature is missing.

Same three questions, different wire

Both APIs ask the same three kinds of question. The differences are in how they are spelled, which matters to anyone translating one into the other, including WorkerKit's integration awaiting rollout.

Three translation traps follow from that table. First, Jev reads JSON state as structure while OpenAI reads text, so a record has to be serialized the same way every time before it goes in; two serializations of one record are two different inputs. Second, a Jev noul can carry criteria spelling out what counts as true, while a predicate has only instructions, so those criteria have to be folded into the instruction text rather than dropped. Third, OpenAI answers should be matched by name rather than position, and a refused answer has no value to match at all.

Price: 2.4x on input, and what that hides

At list price, OpenAI's Decisions input costs about 2.4 times Jev's: $0.10 against $0.042 per million tokens. Neither bills output, and OpenAI does not charge for cache reads or writes. TypeSafe first published its rate on the launch post and now lists it on its models page too, while warning that the rate may be subsidised. Assuming a thousand billable input tokens per item, including questions, with no caching or pricing premiums:

Ten million items is where the gap becomes a budget line. Below that, a few dollars a month is cheaper than the hour it takes to evaluate a second model properly. Four things move the real number away from the list price:

• Tokenizers differ, so the same email is not the same token count on both.
• Serialization adds tokens. JSON flattened into text, and criteria folded into instructions, cost input on OpenAI that Jev reads as structure.
• Images bill as input on OpenAI. Jev has no equivalent cost because it has no equivalent input.
• OpenAI's premiums apply: twice the input rate above 272,000 tokens, and 10% for regional processing. A request that large could never reach Jev, whose ceiling is 64k tokens.

Confidence is not portable

Both APIs return a field called confidence on choice and score answers, and that is where the similarity ends. TypeSafe publishes the formulas: for a choice, how far the top probability sits above an even split across the options; for a score, how tightly the probability gathers around the most likely level. OpenAI's guide returns the field without saying how it is computed. Its advice is to set thresholds from "labeled examples from your application" and "the cost of false positives and false negatives".

So a confidence threshold tuned on one does not transfer to the other. A 0.8 floor on Jev and a 0.8 floor on OpenAI are two unrelated policies that happen to share a number. Neither API returns a confidence for a yes-or-no question; on both, the probability is the uncertainty, and TypeSafe suggests the distance from 0.5 if you want a single figure. In both cases calibrated confidence has to be measured on your own data. A published formula tells you what Jev's number means, not whether it predicts error on your task.

Images, languages and refusals

Images are the clearest functional split. OpenAI accepts up to 128 inline images per request, which suits checks like the "visible damage" example in its guide. Hosted image URLs and file ids are not accepted, so images have to travel as base64 data in the request. Jev is text only: a document that exists only as a scan needs OCR before Jev can judge it.

Languages. TypeSafe says English is where Jev's accuracy is currently best and that other languages "are handled but not equally well". OpenAI's guide makes no statement either way. A non-English workload is the first place to test both.

Known weaknesses. TypeSafe publishes a jaggedness page for Jev 1.13 listing what it does badly: arithmetic ("Jev is not a calculator"), date comparisons, counting, long state full of irrelevant detail, and a pull towards the first-listed option. OpenAI publishes no equivalent for Decisions. That is not evidence that Luna avoids those weaknesses, only that you will have to find its own.

Refusals. OpenAI can return a refusal for any single question. Jev's successful-response schema has no refusal variant, so clients need an explicit branch for OpenAI's. Both providers can also return errors. The safe reading of a refusal is that the item has no judgment: do not treat it as a low probability, do not let an "otherwise" rule fire, and count refusals separately from low-confidence answers so you can see how often they happen.

Model identity. Jev's response names the model that answered, and its aliases point at a versioned model, jev-1.13.0 today. OpenAI's example response says gpt-6-luna. If the weights behind that name change during the beta, an unchanged request can produce different judgments, so keep a labelled set and rerun it.

A fair test: route the same support inbox

Take 1,000 incoming support messages. The first judgment is which queue handles each one: billing, product bug, account access, sales or other. The second is how urgently a person needs to see it. Both APIs can now express both questions, with a distribution and a confidence on each, so the comparison can finally be run instead of speculated about. This is the judging half of a workflow, separate from writing and sending the reply.

Hold everything but the classifier constant: the same messages, the same category definitions, the same other option, the same human-reviewed labels. Then measure what affects operations:

Send images to both only if both can read them, which today means testing image-bearing items on OpenAI alone and keeping them out of the head-to-head. For anything less reversible than a queue assignment, keep a person in the path until your own results support the threshold.

Which one fits which job

• OpenAI Decisions when the evidence includes images or a test on your data shows it wins where Jev is weak. If retention or processing location matters, verify account eligibility and endpoint-specific exceptions in OpenAI's data controls; those options are not automatic WorkerKit guarantees.
• Jev when the input is text or JSON records, when volume is high enough for a 2.4x input difference to show, and when you want a documented confidence formula and a versioned model id.
• Test both when the text is not in English, when the state is long, or when a wrong route costs more than a year of classification.

Where WorkerKit fits

WorkerKit's OpenAI integration is awaiting rollout. Once enabled, decision workers will support a kit default, a worker override and a one-run override, with Jev remaining the default. The initial OpenAI profile handles text items; images and corpus ranking are unsupported. Both providers use the worker's app grants, routing rules and escalation thresholds. New runs using decision profiles record their classifier on a run receipt; a refused question leaves its item unrouted and is recorded separately. Classification uses each provider's list rate with no markup. Structured output is only the start of that contract; permissions, escalation and receipts are the rest.

Two places to start: the Email Category Classifier sorts a window of mail into your own categories, and GitHub Issue Triage decides what each open issue is and how badly it hurts. The public beta explainer walks through switching a worker without carrying a stale threshold across.

FAQ

How is OpenAI's Decisions API different from Jev?

They ask the same three kinds of question about shared evidence: yes or no, which of these, and where on this scale. OpenAI adds image input and per-question refusals and runs on gpt-6-luna. Jev reads JSON state directly, publishes its confidence formulas and limits, and costs about 2.4 times less per input token at list price.

Which is cheaper, OpenAI Decisions or Jev?

At list price, Jev: $0.042 per million input tokens against OpenAI's $0.10, and neither bills output. The real difference on a workload depends on tokenizers, how records are serialized, images, and OpenAI's long-context and regional premiums.

Do both APIs return probabilities and confidence?

Yes. Both return a distribution and a confidence for choice and score questions, and a single probability for yes-or-no questions. The shapes differ, arrays on OpenAI and maps on Jev, and only TypeSafe documents how confidence is computed, so a threshold tuned on one does not carry to the other.

Which of the two accepts images?

OpenAI Decisions, with up to 128 inline base64 images per request and no hosted image URLs or file ids. TypeSafe describes Jev as text only, so scanned documents need OCR before Jev can judge them.

Is the Decisions API just a GPT-6 Luna call?

It uses gpt-6-luna, but through its own endpoint with its own price and answer contract. The Responses API bills Luna at $0.10 in and $0.50 out per million tokens and returns text; Decisions bills input only, returns typed answers, and by OpenAI's measure answers about 10x faster.

Which classifier does a WorkerKit decision worker use?

Jev remains the default. OpenAI selection is awaiting rollout; once enabled, users can choose a kit default, override it on a worker or select it for one run. Each run keeps its selected classifier without silently falling back to another provider. Browse decision model kits to see the workflows.