OpenAI Decisions API vs Jev vs Laya

OpenAI Decisions API, in detail

OpenAI announced the Decisions API at DevDay on September 29, 2026, in limited preview, with a broad release planned in the coming days.^[1] It focuses Luna's intelligence on a specific set of user-defined questions, each with finite pre-defined answers, so the endpoint returns a chosen answer rather than generated text.^[1]

The developer supplies context — text or an image — together with the closed list of allowed answers, and gets back an answer to classify content, route requests, or choose an agent's next action.^[1] Because the answer space is finite, the model cannot answer outside the list.

The API runs on Luna.^[1] Availability is the constraint to watch: it launched as a limited preview, with a broader rollout described as coming in the days after DevDay.^[1]

What OpenAI has not published matters as much as what it has. There is no confirmed price and no published latency or accuracy figure for the Decisions API. Teams evaluating it for production should treat those as open questions rather than filled-in blanks.

In practical terms, the Decisions API is most likely to fit a team that already builds on OpenAI and wants a decision step without introducing a second vendor. The unknown pricing and preview-only status are the main reasons to benchmark before committing.

TypeSafe Jev, in detail

Jev is a System One model from TypeSafe AI, announced September 15, 2026.^[4] Where a large language model generates text token by token, Jev evaluates a piece of state against a set of typed questions and returns typed answers — one per question — in a single parallel pass.^[3]

Its interface is three primitives. Choice picks one option from a set you define and returns a probability for each option. Score places the input on an ordered scale. Noul returns a yes/no as a probability from 0 to 1.^[3] Because every answer must come from the set you defined, Jev cannot produce a malformed type or an out-of-set option — a structural guarantee about the format, not a guarantee that any given answer is correct.^[3]

On calibration, TypeSafe trains Jev with RLCD (Reinforcement Learning for Calibrated Decisions) so that its reported probabilities track real uncertainty in aggregate: a 0.8 means right about 80% of the time across similar cases. Calibration is measured across groups of predictions and does not guarantee any single answer.^{[3] [4]}

TypeSafe reports 70–500 ms latency, $0.042 per million input tokens with output free, and text-only input.^{[6] [2]} Jev is a hosted, closed-weight model. Beyond TypeSafe's own API, it is reachable through gateways such as OpenRouter.^[5]

Jev is the natural fit when the workload is exactly what it was built for: frequent, fast, typed decisions — routing, triage, scoring, guardrails — where calibrated probability lets your code escalate low-confidence cases instead of guessing.

Laya, in detail

Laya is an open-source, Apache 2.0 decision model from Convai Innovations, published shortly after Jev as an openly licensed answer to the same idea.^[8] It shares the choice / score / noul interface but ships as weights you run yourself, not a hosted API.^[7]

Architecturally it is an encoder — a ModernBERT-large backbone with a decision head, 421M parameters total — that scores every candidate answer in a single forward pass.^[8] Available checkpoints cover English, a multilingual variant, and a typed-decisions specialist.^[8]

On output, Laya returns the same typed primitives as Jev — a chosen option, a score, or a yes/no probability — with per-option probabilities, and ships a Jev-compatible HTTP server.^[8] Its defining trade is deployment: because the weights are open, you control inference, data residency, and fine tuning.^[7]

The claims to read carefully are performance numbers. Convai reports roughly 39.5 ms per question on a T4 GPU — a vendor measurement, not an independent benchmark.^[8] Treat those as directional until you have evaluated the model on your own data and workloads.

Laya fits when the constraint is control rather than convenience: self-hosting, data that must stay in your network, or a need to modify the model. The cost is that you own the inference infrastructure and the evaluation.

When to use which

Match the API to the constraint that matters most in your case:

• Existing OpenAI stack — the Decisions API keeps you on one platform and one bill, once it is out of preview.
• Strict typed decisions — Jev's constrained primitives and calibrated probabilities are purpose-built for this.
• Decision-specific workloads at volume — Jev reports 70–500 ms with output-free pricing, aimed at high-frequency calls.
• Experimental or self-hosted integrations — Laya's open weights and local runtime fit prototypes and constrained environments.
• Production maturity — Jev is a shipping hosted API; the Decisions API is in limited preview; Laya is self-managed.
• Migration cost — smallest when your existing stack already matches the target (OpenAI, TypeSafe, or self-hosted hardware).

Decision rule: choose the API that satisfies the constraint you cannot relax — a hosted OpenAI-native step, a dedicated typed-decision model, or open weights you can self-host. None of the three is universally the best.

Is Jev dead?

Since OpenAI's DevDay announcement, community threads with titles like “Jev Is Dead” and “Jev killer” framing have circulated on Reddit and developer outlets. Those are headlines and community reactions to a competitive launch, not product status.

On the verifiable facts, TypeSafe has not announced a shutdown or sunset. Its documentation remains online and Jev remains accessible through its API and gateways as of the last update on this page. There is no verified basis here to treat a provocative headline as an official shutdown notice.^[4]

Migrating from Jev to Decisions API

This page does not provide migration code, because the two APIs are not drop-in replacements. If you are weighing a move, check each of the following before writing anything:

• Schema differences — Jev uses choice / score / noul; the Decisions API uses a finite set of pre-defined answers.
• Output semantics — the precise fields differ per vendor; they do not map one-to-one.
• Confidence / probability behavior — Jev's calibration is trained for; the Decisions API's confidence behavior is not published. Treat them as different signals.
• Error handling — different auth, rate-limit, and failure models per vendor.
• Authentication — separate keys and providers.
• Availability — Jev is a shipping hosted API; the Decisions API is in limited preview.
• Pricing — Jev has published token pricing; the Decisions API's pricing is not yet confirmed.
• Latency — Jev reports a published range; the Decisions API has no official figure yet.
• Production readiness — Jev is generally shipping; the Decisions API is not yet generally available.
• Vendor-specific SDK assumptions — any helpers, adapters, or schemas built around Jev will need rewriting.

Anything on this list you cannot yet answer for your workload is a reason to hold off. Read what Jev is and the OpenAI Decisions API breakdown before deciding.