OpenAI Decisions API vs Jev:

OpenAI's Decisions API (GA since Oct 22) and TypeSafe's Jev both return typed answers with probabilities and bill input only. Compare price, caching, inputs, limits, access and output shapes, with the same ticket-routing request in both, then test both in one Apidog project.

Ashley Innocent

Ashley Innocent

26 October 2026

OpenAI Decisions API vs Jev:

Apidog for Enterprise

On-Premises Deploy

SSO & RBAC

SOC 2 Compliant

Explore Apidog Enterprise

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.

button

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:

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.

button

Explore more

What Is OpenCode Browse?

What Is OpenCode Browse?

OpenCode Browse lets Claude Code, Codex, Cursor or OpenCode drive your own signed-in browser, with handoffs for logins and payments. Here's how it works, how to install it, how it compares with Playwright MCP and Chrome DevTools MCP, and how to turn captured traffic into teste...

17 November 2026

What Is ERNIE 5.5 Flash?

What Is ERNIE 5.5 Flash?

ERNIE 5.5 Flash is Baidu's 280B-parameter MoE with 14B active and a 1M-token context, released as a Base checkpoint and a post-trained Preview. Here is how the two differ, what the architecture changes, what Baidu's benchmarks show and how to access it.

12 November 2026

What Is MiniMax H3-Image?

What Is MiniMax H3-Image?

MiniMax H3-Image generates and edits 16-megapixel images, and its weights are open under a community license. Here is what MiniMax claims, what the license allows, where to use it and what it costs.

11 November 2026

Practice API Design-first in Apidog

Discover an easier way to build and use APIs

OpenAI Decisions API vs Jev: