Shortly after TypeSafe released Jev, OpenAI put its own decision endpoint into public beta, running on GPT-6 Luna and answering the same kinds of typed questions. For teams already routing or gating agent calls with Jev, the question became whether OpenAI's version is a better place to run those decisions.
Both return probabilities instead of text, and both handle choice, score, and yes-or-no questions. The differences show up in what each one gets wrong and in what each one accepts and costs.
Two independent tests agree that Jev is more accurate, and one also found it better calibrated, while OpenAI's API is faster, takes images, and repeats its answers more consistently across reruns. Neither is a universal pick, and the right one depends on which weaknesses your agent can tolerate.
Here's the OpenAI Decisions API vs Jev comparison, section by section, and which to use in 2026.
TL;DR: OpenAI Decisions API vs Jev
The two APIs share a question format, and the differences come down to the numbers below.
| OpenAI Decisions API | Jev | |
|---|---|---|
| Accuracy (Anand / Akita tests) | 71.4% / 90.5% | 89.2% / 97.6% |
| Calibration (Brier, lower is better) | 0.296 | 0.117 |
| Same route on rerun | 100% of cases | 95.2% of cases |
| Median latency (OpenRouter) | 0.15s | 0.19s |
| Input price (per 1M tokens) | $0.10 | $0.042 |
| Image input | Yes, base64 only | No |
| Model versions | One documented model ID | Versioned IDs plus aliases |
| Data residency | US and Europe | Not published |
| Status | Public beta | Generally available |
For decisions about a whole agent trace rather than a single input, Span-01 is the option to look at.
What is OpenAI's Decisions API?
OpenAI's Decisions API is an endpoint, POST /v1/decisions, that returns probabilities for questions you define instead of generated text. It runs only on GPT-6 Luna, and it's in public beta, with OpenAI saying it expects general availability in the coming weeks.
It arrived in a crowded field, and it competes with the other best AI decision models on accuracy and price rather than on interface, since the question types are much the same.
The name causes some confusion. OpenRouter's System One endpoint labels its schemas "Decisions" and serves Jev, so a request built from OpenRouter's docs isn't the same thing as a call to OpenAI's /v1/decisions.
How does OpenAI's Decisions API work compared to Jev?
Both are LLM classifier models with a typed interface: you describe the situation, ask structured questions, and get probabilities back. OpenAI calls the situation an input, which can be text or text with images, while Jev calls it a state, which can be a string, JSON, or an array of text values.
The question types map closely. OpenAI's predicate and Jev's noul both return the probability that a statement is true, and both APIs offer a choice question that returns the selected option, a confidence, and a probability per option, plus a score question that returns a probability-weighted position on an ordered scale.
The main behavioral difference is refusals. An OpenAI question can come back as a refusal instead of an answer, so your code has to handle that case, while Jev's answers always come back in the schema you defined. Underneath, OpenAI runs a general model, GPT-6 Luna, behind a decision interface, while the Jev AI model was built as a System One model that never generates text.
OpenAI Decisions API vs Jev: Accuracy
Neither vendor publishes an accuracy comparison, so the evidence comes from two independent tests. Kartik Anand's benchmark ran 500 synthetic withdrawal-routing cases through both APIs on OpenRouter, in every option order across two runs, with the OpenAI request translated into OpenAI's Decisions format. Fabio Akita's benchmark ran operational decision tasks in English and Brazilian Portuguese through each vendor's hosted API, and since both tests used synthetic cases, they're best read as two data points that agree rather than a final verdict.
OpenAI Decisions API: 71.4% macro-F1 in Anand's test, ranging from 60.6% to 86.6% depending on option order, and 90.5% accuracy on Akita's compact tasks.
Jev: 89.2% macro-F1 in Anand's test, measured on the option order that was its weakest, and 97.6% accuracy on Akita's compact tasks.
OpenAI Decisions API vs Jev: Speed
OpenAI's API is faster in every available measurement, though the gap is tens of milliseconds rather than hundreds.
OpenAI Decisions API: A 0.15-second median latency on OpenRouter, and 214 ms median in Anand's test.
Jev: A 0.19-second median latency on OpenRouter, and 233 ms median in Anand's test.
OpenAI Decisions API vs Jev: Pricing
Both charge for input tokens only, but the same request can use a different number of tokens on each API, so measured cost per decision says more than the list price.
OpenAI Decisions API: $0.10 per 1M input tokens, with output and cache reads free, though regional processing premiums and long-context multipliers can apply. Anand measured $61.10 per million decisions, and Akita's figures work out to $23.31.
Jev: $0.042 per 1M input tokens with output free, though TypeSafe says it can't yet show that this price isn't subsidized. Anand measured $32.40 per million decisions, and Akita's figures work out to $19.16.
OpenAI Decisions API vs Jev: Reliability
Reliability here means whether the probabilities can be trusted, and whether answers stay stable as option order, reruns, and model versions change.
OpenAI Decisions API: It gave the same route on all 500 cases across Anand's two runs, with identical probabilities on 498, but the same route across all six option orders only 64.2% of the time. Its Brier score was 0.296, and Akita found its yes-or-no probabilities handled random-event probes well while its choice probabilities were biased on them. OpenAI's docs list a single model ID, gpt-6-luna.
Jev: It posted a 0.117 Brier score and gave the same route across all six option orders 91.6% of the time, but 24 of 500 cases changed route between runs. TypeSafe publishes versioned IDs alongside the jev-latest alias and recommends you pin a specific version if you've tuned thresholds against it.
OpenAI Decisions API vs Jev: Inputs and limits
The largest functional difference is image input, which only OpenAI supports.
OpenAI Decisions API: Text, or text with images passed as inline base64, since hosted image URLs aren't supported, with 2 to 255 options per choice question. OpenAI doesn't state a context limit, OpenRouter lists 1.1M tokens, and long-context pricing multipliers apply.
Jev: Text only, as a string, JSON, or text array, with a 64K-token budget for the state plus all questions and 32K for the state plus the longest single question. Rate limits are 80 requests and 100K tokens per second.
OpenAI Decisions API vs Jev: Data handling
Data terms matter once your decisions run on regulated or customer data.
OpenAI Decisions API: Zero data retention and HIPAA use are available for eligible customers, with data residency in the US and Europe.
Jev: TypeSafe doesn't train on your inputs, offers zero data retention to enterprise customers, and holds SOC 2 Type II, per its enterprise data terms. It doesn't publish data residency or BAA terms.
Which to use: OpenAI Decisions API or Jev?
The two APIs share a question format, so switching later is mostly a matter of request code and re-tuned thresholds, which makes the first choice lower-stakes than it looks.
Choose the OpenAI Decisions API if
You need image input, lower latency, or EU data residency and HIPAA coverage, and you can measure accuracy on your own cases before relying on it. Both independent tests found it behind Jev on accuracy, and Anand's also found it more sensitive to option order, so test with your options shuffled.
Choose Jev if
Accuracy and calibration matter most, your inputs are text, and you want documented version pinning at a lower price per token. If self-hosting matters more than either API, the open-weight Jev alternatives are worth a look.
Classify agent behavior across traces with Span-01
Both APIs answer a question about a single input. Some of the decisions an agent team cares about are about the whole run instead, like whether the agent refused, missed an instruction, or left the user frustrated, and those need a model that reads the full trace.
Span-01 is Respan's classifier for that job. You describe a behavior in plain language, and it scores whether that behavior happened across the trace in one forward pass, without generating text.
- Behaviors in plain language - Write definitions like "the agent called a tool the user didn't ask for," including ones Span-01 hasn't seen before.
- Many behaviors in one pass - Each definition runs as its own branch over the same trace, with no per-request limit on how many you check.
- Answers you can threshold - Each behavior comes back as present, absent, or not observable, so missing evidence reads as unknown instead of a false negative.
- Built-in and custom behaviors - Respan's Behaviors feature ships built-in behaviors such as refusals, instruction misses, and incomplete answers, and you can add your own.
- Free to start - Span-01 Lite is free within a daily cap, and Span-01 costs $0.02 per million input tokens with free output.
Because Span-01 runs on the traces Respan already captures, a bad score opens straight onto the trace behind it.
FAQ
Is the OpenAI Decisions API the same as GPT-6 Luna?
No. The Decisions API is an endpoint that runs GPT-6 Luna, currently the only model it supports, and returns probabilities for the questions you define instead of generated text. GPT-6 Luna on its own is a general model you call for text responses.
Is the OpenAI Decisions API more accurate than Jev?
Not in the independent tests available. Jev scored 89.2% macro-F1 to OpenAI's 71.4% in Kartik Anand's routing test and 97.6% to 90.5% on Fabio Akita's compact tasks, though both tests used synthetic cases, so it's worth running both on your own labeled examples before deciding.
How much does the OpenAI Decisions API cost?
It costs $0.10 per million input tokens, with output and cache reads free, though regional processing premiums and long-context multipliers can apply. That's more than twice Jev's $0.042 list price, and in Kartik Anand's test it worked out to $61.10 per million decisions against Jev's $32.40.
Can you switch from Jev to the OpenAI Decisions API?
Yes, but not as a drop-in. The question types map closely, with OpenAI's predicate standing in for Jev's noul, but the request shape and response fields differ, and OpenAI's answers can come back as refusals your code has to handle. Thresholds tuned on Jev's probabilities are also unlikely to carry over, so re-tune them on OpenAI's outputs before switching.
