Jev in one sentence
Jev is a decision model released by TypeSafe AI in September 2026. Its key difference from models like ChatGPT is blunt: it does not write prose and does not chat, it only decides.
You hand it a piece of state (a support ticket, an alert, a log line) together with a few typed questions, and it returns structured answers directly: which option was chosen, what score, what probability that a statement holds, each with a confidence value. In other words, it turns "ask an AI to judge this" from "generate some text and then figure out how to parse it" into "call a function and get a return value".
Why Jev exists: software needs a decision interface, not prose
The last two years made us used to models that talk and write, but in real systems most steps do not need a nice paragraph, they need something you can put straight into an if statement: should this comment be blocked? which team owns this email? is this a duplicate order? should this alert escalate?
Using a generative model for that has three persistent problems:
- Latency: even a one-word answer is generated token by token, and that delay sits right on the critical path;
- Cost: at hundreds of thousands of items a day, per-token pricing gets out of hand quickly;
- Fragility: the output is free text, so you need prompt constraints, JSON parsing and retry handling, and any drift either breaks the parse or quietly appends an explanation.
Jev's approach is to extract that class of need into a primitive of its own: the output space is finite and known in advance (choices, scores, boolean probabilities), so there is no need to generate a paragraph and no need for parsing fallbacks. The vendor claims up to roughly 200x faster and, at best, about 1/400th the cost on classification-style decisions; those figures come from the vendor and early users, and the real gain depends on input length and question complexity, treat them as orders of magnitude, not promises.
How you actually use it: three question primitives
The call shape resembles any ordinary API: one request carries a state and several questions, and each question declares its type and allowed values. Per the official documentation there are three main primitives, and they can be mixed in a single call:
- Choice: pick one of up to 255 predefined options, returning the probability of each, good for "which category is this".
- Score: rate the state against criteria you supply, good for "how strong is this lead".
- Noul: decide whether a statement holds, returning a probability between 0 and 1, good for "does this comment contain abuse".
One design rule matters more than the rest: every question must be atomic and single-dimensional. Do not pack "is this a complaint, should it be escalated, and who should own it" into one question. Split it into three, let them return in parallel within one call, and compose the business logic in your code. Accuracy improves, and when something is wrong you can see which step judged badly.
Why it is fast and cheap
The core reason is that it does not generate a string. A generative model's cost grows with output length, whereas Jev's output space is fixed before the call: one of a few options, one score, or one probability. With no token-by-token sampling, latency is low and the unit cost is small.
It also answers multiple questions in one call, collapsing "ten judgements" into "one round trip", which matters a great deal when processing large batches.
Where it genuinely helps
- Ticket and email routing: decide the owning team and priority, auto-dispatch the easy majority, and pull out only the uncertain cases for people.
- Moderation and classification: batch-decide whether content violates policy and which class it belongs to, then use confidence thresholds to choose between automatic action and human review.
- Lead and risk scoring: score leads, refund requests or anomalous logins, using the score only for sorting and filtering while the final decision stays in business rules.
- The decision layer of an agent: let the model that orchestrates tools focus on "how", and hand discrete judgements to Jev, cutting the latency and uncertainty of long reasoning chains.
- Pre-sorting for humans: order a large queue by "how much human attention this deserves" so people spend their attention on the few genuinely hard or high-risk items.
How it differs from rules engines and classic classifiers
Rules engines handle deterministic logic well, but maintenance cost climbs with rule count. Purpose-trained discriminative models are accurate but need fresh labelling and training for every new task. Jev sits between them: as quick to define as a rule, as language-aware as a model. Describe the question and the options in words and you have a shippable decision interface within minutes.
Try it: JSON formatter