The OpenAI Decisions API and TypeSafe’s Jev do the same job: send an input and a set of questions, get back typed answers with probabilities instead of text to parse, and pay for input tokens only. Decisions costs $0.10 per 1M input tokens, has been generally available since 2026-10-22, accepts text, images and JSON, and runs on GPT-6 Luna. Jev costs $0.042 per 1M input tokens, sits behind a TypeSafe console account, is text only, and caps each request at 64k tokens by default (262k with an opt-in header).
For the basics, start with what the Decisions API is and how to use Jev. This post compares them row by row, then wires both into one Apidog project behind one confidence rule.
Side-by-side comparison
Every cell comes from the vendor pages linked in the sections below.
| OpenAI Decisions API | TypeSafe Jev | |
|---|---|---|
| Endpoint | POST /v1/decisions |
POST /v1/systemone |
| Model | gpt-6-luna only |
Jev 1.14 (jev-latest) |
| Status | GA since 2026-10-22 | launch post described early access; docs state no tier; direct access via a console account |
| Input | text, images (base64 or public URL) and JSON | text only, 64k per request by default, 262k with the opt-in long-context header |
| Question types | predicate / choice / score |
noul / choice / score |
| Questions shape | array with optional name, up to 400 per request |
object keyed by id |
| Output fields | probability; choice or score + probabilities + confidence; refusal |
noul; choice or score + confidence + probabilities |
| Price | $0.10 per 1M input, no output charge | $0.042 per 1M input, no output charge |
| Caching | cached input $0.01 per 1M; writes $0.125 / $0.25 per 1M | not published |
| Rate limits | per-org limits page | per-org, shown in the console |
| Speed claim | “about 10x faster than the Responses API” (OpenAI) | 70 to 500 ms end to end (TypeSafe) |
| Data | ZDR + HIPAA for eligible customers; US/EU residency | ZDR for enterprise; not trained on requests |
Decisions is an endpoint, not a model; it runs on GPT-6 Luna. Jev is TypeSafe’s “System One model”, trained with RLCD to return calibrated decisions, and not a general LLM.
The same ticket-routing request in both shapes
A support ticket arrives; you want a department plus a yes/no on whether the customer wants a refund. Decisions first: questions are an array, each with a type, instructions, and an optional name the API echoes back.
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 team should handle this ticket?",
"choices": [
{"value": "billing", "description": "Charges, refunds"},
{"value": "technical", "description": "Bugs, errors"},
{"value": "other"}
]
},
{
"type": "predicate",
"name": "wants_refund",
"instructions": "Is the customer asking for money back?"
}
]
}'
Now Jev: the input field is state, the questions are an object keyed by ids you choose, choice takes a criteria map of option to description, and the yes/no type is noul.
curl https://api.typesafe.ai/v1/systemone \
-H "Authorization: Bearer $TYPESAFE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "jev-latest",
"state": "I was charged twice for my order.",
"questions": {
"department": {
"type": "choice",
"instructions": "Which team should handle this ticket?",
"criteria": {
"billing": "Charges, refunds",
"technical": "Bugs, errors",
"other": "Anything else"
}
},
"wants_refund": {
"type": "noul",
"instructions": "Is the customer asking for money back?"
}
}
}'
What comes back
Decisions returns model, answers, and usage. Answers arrive in the order asked, each with its name; per-option probabilities are an array of objects. Note output_tokens: 0.
{
"model": "gpt-6-luna",
"answers": [
{
"type": "choice",
"name": "department",
"choice": "billing",
"probabilities": [
{"value": "billing", "probability": 0.95},
{"value": "technical", "probability": 0.02},
{"value": "other", "probability": 0.03}
],
"confidence": 0.93
},
{"type": "predicate", "name": "wants_refund", "probability": 0.95}
],
"usage": {
"input_tokens": 42,
"input_tokens_details": {"cached_tokens": 0, "cache_write_tokens": 0},
"output_tokens": 0,
"output_tokens_details": {"reasoning_tokens": 0},
"total_tokens": 42
}
}
Jev returns model (the versioned id), an answers object keyed by your question ids, and usage with input_tokens and output_tokens. You read answers.department.choice, its confidence, and probabilities keyed by option name, plus answers.wants_refund.noul. On the OpenAI side only, a refusal answer can appear per question while the others still get answers.
Price per million, and what a million tickets cost
On the GA pricing page, gpt-6-luna on Decisions costs $0.10 per 1M input tokens with no output-token charge. Prompt caching is now priced too: cached input is $0.01 per 1M, and cache writes bill at standard Luna rates, $0.125 per 1M for 30 minutes or $0.25 per 1M for 12 hours. TypeSafe lists $0.042 per 1M input tokens and free output.
Take a 500-token ticket with the two questions above:
- Decisions: 500 / 1,000,000 x $0.10 = $0.00005 per request. One million tickets = $50.
- Jev: 500 / 1,000,000 x $0.042 = $0.000021 per request. One million tickets = $21.
Two multipliers apply on the OpenAI side: long-context input (over 272K tokens) costs $0.20 per 1M ($0.02 cached), and regional processing adds 10%. No Batch or Flex tier is documented for /v1/decisions. Caching changes the math when tickets share a long system prompt: a shared prefix of at least 1,024 tokens is cached by default, and usage reports cached_tokens and cache_write_tokens inside input_tokens. Jev publishes nothing on caching.
Inputs: images on one side, text on the other
Decisions takes a string or an array of user messages mixing input_text, input_image and input_json parts, and images can also go in a question’s instructions. The GA guide documents both base64 data URLs and hosted public HTTP(S) URLs, so the earlier guide-versus-reference conflict is gone. file_id, files, and audio still aren’t supported.
Jev is text only: a string, a JSON object, or an array of text, with no image, audio, or video input per TypeSafe’s models page. On the OpenAI forum, sam.saffron put it plainly: image understanding is something Jev does not support yet. If your decision depends on a photo, only Decisions can look at it.
Context and rate limits
Jev’s default is 64k tokens per request and 32k per question; an opt-in long-context header, off by default, raises both to 262k. TypeSafe says Jev ingests the state once and evaluates every question in parallel. Its models page no longer publishes rate-limit numbers: limits are set per organization, shown in the developer console in tokens and requests per second, with a 429 over the limit.
OpenAI publishes no context-window figure and no Decisions-specific rate limit; Luna’s 1,050,000-token window is a model-page number, not an endpoint one. Check Settings > Organization > Limits (rate-limits guide); our rate-limit guide covers 429 handling on either side.
Status and access
Decisions went GA on 2026-10-22 with gpt-6-luna, after a public beta that opened on 2026-10-06, per OpenAI’s launch page and the changelog. GA also brought prompt caching, 400 questions per request, and an org usage endpoint.
TypeSafe’s launch post described early access; the current docs don’t state an availability tier, and the newest release is Jev 1.14, available from 2026-10-14. Direct access to api.typesafe.ai sits behind a TypeSafe console account; how to access Jev walks the routes and Jev API key covers key creation. The second route is Vercel AI Gateway, where Jev is typesafe-ai/jev, called through experimental_evaluate in the AI SDK (7.0.105 or later), per the Vercel changelog; Vercel’s evaluation docs say it isn’t exposed on the Gateway’s OpenAI-compatible endpoint, and there the yes/no type is boolean, returning the probability of true.
Data controls
OpenAI says Decisions supports Zero Data Retention and HIPAA use for eligible customers, with data residency and regional processing in the United States and Europe (EEA plus Switzerland); the data controls page adds that abuse-monitoring logs for /v1/decisions are kept up to 30 days by default. TypeSafe says Jev isn’t trained on customer requests or responses and offers ZDR for enterprise customers.
Neither vendor publishes accuracy or calibration figures; OpenAI’s guide tells you to set thresholds from your own labeled examples, and that applies to Jev too.
Speed, then which to pick
OpenAI says Decisions is about 10x faster than the Responses API and publishes no absolute latency number. TypeSafe quotes 70 ms to 500 ms end to end for Jev. Those aren’t comparable measurements, so time both on your own tickets.
Pick Decisions when the input includes images, when you’re already on OpenAI and want one key and one bill, or when you need HIPAA coverage under an OpenAI BAA. Pick Jev when the input is text, when the lower per-token price matters at your volume, or when you’re on Vercel AI Gateway already.
Running both for a few weeks is sane: score each on the same labeled set and keep the other as a fallback. If the real question is Decisions versus a Structured Outputs label, see Decisions vs Responses; if neither vendor fits your data policy, open-source Jev alternatives exist.
Test both in one Apidog project
Two environments. Create OpenAI with OPENAI_API_KEY and TypeSafe with TYPESAFE_API_KEY, each with the value in the local field so it never syncs to the team (environments and secret variables covers the scoping).
Two saved requests. POST https://api.openai.com/v1/decisions with Bearer {{OPENAI_API_KEY}} and the first body above; POST https://api.typesafe.ai/v1/systemone with Bearer {{TYPESAFE_API_KEY}} and the second.
One assertion rule, applied twice. The business rule: confidence above 0.8 routes the ticket automatically, anything lower goes to a review queue. On the Decisions request, assert status 200, $.answers[0].choice equals billing, $.answers[0].confidence greater than 0.8, and $.usage.output_tokens equals 0. On the Jev request, assert $.answers.department.choice equals billing and $.answers.department.confidence greater than 0.8.
A data-driven scenario. Put twenty labeled tickets in a CSV with the expected department, run both requests over it as a test scenario, and see which API’s confidence drops below 0.8 on the ambiguous rows. That’s how you pick thresholds, and it catches a model change before tickets misroute.
Mock both shapes. Save a Decisions response and a Jev response as mocks so the frontend can be built against a stable answers array and answers object; mocking conditional responses returns the low-confidence case on demand to exercise the review-queue branch.
Run it in CI. Run the scenario with the Apidog CLI (apidog run with the cli or junit reporter) on every deploy, so a field change in a future release or a jev-latest bump turns the build red, not the support queue. Download Apidog to set this up.
FAQ
Is Jev an LLM like GPT-6 Luna? No. TypeSafe describes Jev as a System One model trained with RLCD to return calibrated decisions; it doesn’t generate text. Decisions is an endpoint on the general-purpose Luna model.
Which one is cheaper? Jev, at $0.042 per 1M input tokens versus $0.10; on a million 500-token tickets, $21 versus $50.
Can either one return my own JSON schema? No. Both return fixed answer shapes; for extracted fields or a written explanation, use Structured Outputs on the Responses API.
Next step
Send the two curl requests above with the same ticket, save both in Apidog, and add the 0.8 confidence assertion to each. Then swap in twenty of your own tickets and see which API crosses your threshold more often. The how-to-use guide has the Python and JavaScript versions.



