OpenAI Decisions API vs Jev:

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, is in public beta, accepts text and images, and runs on GPT-6 Luna. Jev costs $0.042 per 1M input tokens, is in early access behind a TypeSafe console account, is text only, and caps each request at 64k tokens.

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 in the references.

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

OpenAI’s wording: with gpt-6-luna, input costs $0.10 per 1M tokens, with no cache-read, cache-write, or output-token charges. 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) is 2x, so $0.20 per 1M, derived from the pricing page, and regional processing adds 10%. No Batch, Flex, or Fast tier is documented for /v1/decisions, and per OpenAI’s forum there’s no prompt caching yet, although usage carries cached_tokens and cache_write_tokens fields. 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 and input_image parts. The guide says images must be inline base64 data URLs; the API reference also lists public HTTP(S) URLs and up to 128 images per request, so treat base64 as the safe path and test hosted URLs before relying on them. file_id, files, and audio 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 publishes a 64k-token limit per request, 32k of it for state plus the longest question, and says it ingests the state once and evaluates every question in parallel. Its models page lists 100K tokens per second and 80 requests per second, adjusting dynamically, with a 429 over the limit. Those numbers have changed since September, so read the live page.

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 to public beta on 2026-10-06, open to all developers per the announcement; the guide says OpenAI expects GA “in the coming weeks”, with no date.

Jev is in early access per TypeSafe’s launch post, which mentions a waitlist, and 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, offers ZDR for enterprise customers, and runs the same weights for every account.

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; one developer on the OpenAI forum reported image-input decisions in about 0.8 seconds on a slow connection. 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 against the same labeled set, keep the better threshold curve, and hold 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 at GA 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.

Did OpenAI build the Decisions API in response to Jev? OpenAI’s pages don’t say that, and we don’t claim it. Both ship the same idea: typed answers with probabilities, billed on input.

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.