Every AI model you’ve used generates text one token at a time — even when all you actually needed was “yes” or “which of these five.” TypeSafe AI built a model that skips the text entirely.
What it is
Jev is TypeSafe AI’s flagship model, launched September 15, 2026, which the company calls a “System One model” — built specifically “for decisions inside software,” not conversations with humans (typesafe.ai: typesafe.ai). Where a chat model “thinks out loud” and returns a string to parse, Jev “evaluates typed questions against a state and returns structured results directly… You get typed values and probability distributions that your code can branch on, sort by, and route with” (official docs: docs.typesafe.ai).
TypeSafe’s own stated reasoning: RLHF, the technique behind most chat models, “creates inherent issues such as mode dropping, overconfidence, and lack of reliability” when software rather than a person needs to act on the output (typesafe.ai). Jev is trained instead with what the company calls RLCD — reinforcement learning for calibrated decisions.
The three primitives
Everything Jev does reduces to three question types, evaluated in parallel against the same state in one call: Choice (pick one option from a fixed list, returns the winner plus a probability per option plus confidence), Score (rate against a rubric, returns a probability-weighted score plus a legend), and Noul (a yes/no question returned as a probability rather than a hard boolean, so the calling code sets its own threshold) — per the official docs page. Because each question is atomic and evaluated independently, adding questions to one call “barely changes response time” (same source) — there’s no accumulating context the way a chat conversation grows.
The numbers, and whose numbers they are
TypeSafe’s own published comparison claims “193.6x Faster, 444.6x Cheaper” than an LLM on the same workflow-style task — $0.000081 and 0.114 seconds for Jev versus $0.013880 and 8.566 seconds for a comparable LLM call, per typesafe.ai’s own benchmark chart. That comparison has not been independently reproduced at time of writing; it is the vendor’s own methodology and their own chosen comparison task. Published pricing is $0.042 per million input tokens with no output-token cost, since the model doesn’t generate output tokens in the traditional sense (jev-agent.com, a third-party site that explicitly discloses it is “independent and unofficial” and “not affiliated with or endorsed by” TypeSafe — used here only for this pricing detail, cross-checked against the same figure appearing on typesafe.ai’s own site). Latency is quoted at 70-500ms end to end, 64k token context, text-only at launch.
Where it actually fits
TypeSafe’s own guidance, and the pattern in third-party writeups describing real use, converge on the same idea: reach for a decision model like Jev “when the answer needed is a decision, not a sentence” — tool routing, intent classification, grading output against a rubric, boolean guardrails — and skip it entirely for prose, code, or conversation, which it structurally cannot produce. Most production systems described in the available writeups end up using both: a fast, cheap, typed model deciding what happens next, and a slower, expressive model doing the writing.
Why this matters beyond one product
The interesting part isn’t really Jev specifically — it’s the argument underneath it. Every agent framework doing real work has been quietly forcing a text-generation model to do a classification model’s job, because that’s what was available with an API and a prompt. If a purpose-built decision model at a fraction of the cost holds up under independent, third-party benchmarking (which does not yet exist for Jev as of this writing), that’s a real case for a two-model pattern — fast typed decisions plus slower expressive writing — becoming standard in agent systems.