Jev: The Model That Returns Decisions Instead of Text

Every AI feature most of us have shipped in the last three years has the same shape underneath: ask a language model a question, get a string back, then spend real engineering effort convincing that string to become a value your code can branch on. JSON mode, schema validation, retry loops, a parser that quietly swallows the third malformed response of the hour. We built an entire layer of software whose only job is to turn prose back into data.

On 15 September 2026, TypeSafe AI came out of stealth with a model that deletes that layer. It's called Jev, and it does not generate text at all.

What changed

Jev is the first of what TypeSafe calls System One models — a category name borrowed from Daniel Kahneman's Thinking, Fast and Slow, where System 1 is the fast, intuitive judgement and System 2 is the slow deliberate reasoning. Today's frontier LLMs are System 2 machines pressed into System 1 jobs. Jev is built for the other half.

The framing from founder and CEO Diogo Almeida — a former OpenAI researcher who worked on the RLHF methods behind ChatGPT — is a pointed question: "Models have been superhuman at chat for years, so where is all the automation?" His answer is that chat-shaped models are the wrong tool for the decisions software actually needs to make thousands of times a second.

So Jev takes unstructured state in and returns typed probabilistic decisions out. TypeSafe describes it as "a frontier-intelligence function call." There is no string to parse, because there is no string.

How it works

TypeSafe didn't fine-tune an existing LLM into behaving. They claim a new stack top to bottom: a new model architecture, a parallel sampler, and a training method they call Reinforcement Learning for Calibrated Decisions (RLCD) in place of the RLHF and RLVR that shaped the chat models.

The practical consequence is the sampling behaviour. Instead of producing tokens one after another, Jev generates all outputs for a query in parallel. You send one state plus a set of questions, each question is evaluated independently and in isolation, and adding more questions barely moves the response time.

There are three primitives, and that's the whole surface area:

• Choice — pick an option from a list. Returns the choice, the full probability distribution, and a confidence score. Supports cardinality up to 255.
• Score — rate the state against a rubric. Returns the score plus probabilities and confidence.
• Noul — is this statement true? Returns a value on a 0–1 scale rather than a hard boolean.

All three can be mixed in a single call against the same state. Every answer arrives with a calibrated confidence number attached, which is the part worth dwelling on: you can route on uncertainty. Low confidence escalates to a bigger model or a human; high confidence runs straight through. That's an architecture you cannot reliably build on an LLM that has been asked politely to rate its own certainty, because — as TypeSafe puts it — "even if prompted for a confidence estimate, models tend to be overconfident."

And because the output space is a defined schema rather than a token stream, a type error is structurally impossible. There is no value Jev can emit that isn't in the set you declared.

The numbers

TypeSafe's published figures are aggressive:

• Latency: 70ms–500ms end to end.
• Speed: 40x–200x faster than frontier LLMs at comparable intelligence on System One tasks; a headline 193.6x on their workflow evaluation.
• Cost: $0.042 / MTok input — $42 per billion tokens — against $0.20–$10/MTok for typical LLM input. Output tokens are free, described as "too cheap to meter."
• Efficiency: 444.6x cheaper on the same workflow evaluation, benchmarked against GPT-6 Astra and Fable 5.1.

Two demos carry the argument better than the benchmarks do. The first is Doom: Jev plays it in real time at roughly 10 queries per second, reading structured game state and deciding what to do, for about $7 per hour of play. The second is Wikiracing — navigating Wikipedia toward a target article, where each step offers hundreds to thousands of candidate links. That's the case where an LLM's tendency to invent a plausible-looking option that isn't on the page becomes fatal, and where picking from a closed set of 255 is exactly the right primitive.

The caveats, including theirs

The announcement is unusually candid about where the numbers come from, and that deserves repeating rather than burying:

• The 193.6x / 444.6x workflow figures are, in TypeSafe's own words, "on the higher end of real world gains."
• Those workflows were built by TypeSafe's own capability team — a real source of selection bias.
• The speed and cost demos use simplified queries with "descriptive, human-readable keys."
• The no-hallucination guarantee is a structural claim about the output space, not an empirical error rate. Jev cannot emit an invalid value; it can still emit a wrong one, confidently.
• The Doom demo feeds structured state, not pixels. This is not a vision model.
• The Wikiracing comparison ran the LLMs in non-reasoning modes.
• The docs themselves flag "Jev 1.13 jaggedness" — known rough edges awaiting fixes.

Worth being clear-eyed about the shape of the trade, too. You are giving up open-ended generation entirely. Jev will not write your copy, summarise a document, or hold a conversation. It answers questions you defined in advance. That constraint is the whole product.

Where it fits

The use cases TypeSafe leads with map neatly onto work most teams already do badly with LLMs: classify, route, score, extract, and branch where hand-written rules are too brittle; map-reduce over large datasets to produce features; real-time paths where 100ms latency is a UX requirement rather than a nice-to-have; and — the one we find most immediately useful — grading the other model, as a judge, guardrail, verifier, or jailbreak detector sitting in front of an expensive LLM call.

That last pattern is the honest near-term read. Jev is less a replacement for your language model than a cheap, fast, type-safe control plane wrapped around it.

Getting access

This part moved fast. Jev launched behind a waitlist on 15 September, and six days later TypeSafe removed it entirely — on 21 September the company posted that "Jev is now available to everyone. No waitlist." Signup at console.typesafe.ai is instant, and new accounts get $5 in free credit, which TypeSafe puts at roughly 120 million tokens.

One distinction worth holding onto: open signup is not the same as general availability, and TypeSafe hasn't claimed it is. The homepage still invites you to try Jev "in early access." Anyone can get a key; the product is still labelled early.

There are Python (TypeSafeClient and AsyncTypeSafeClient) and JavaScript SDKs over an HTTP API, with keys via environment variables and documented retry and error handling. The docs at docs.typesafe.ai ship 16+ cookbooks covering fan-out, confidence routing, composite scoring, re-ranking, function calling, and RAG passage classification. TypeSafe has said detailed evaluation data is coming to evals.typesafe.ai, along with a Doom walkthrough and hackathons.

Our take

The name is the tell. Jev is short for William Stanley Jevons, the economist behind the observation that making a resource dramatically cheaper tends to increase total consumption rather than reduce it. TypeSafe is betting that two orders of magnitude off the price of a machine decision doesn't just save money on the AI calls you already make — it makes a whole class of calls viable that nobody would have written at LLM prices. An if-statement you'd never have paid a model to evaluate, ten times a second, forever.

Whether the benchmarks hold up outside TypeSafe's own workflows is the open question, and one that early-access developers will answer faster than any press cycle. But the underlying observation is sound regardless of how the numbers land: an enormous share of what we currently ask language models to do isn't language work at all. It's a decision, wearing a paragraph as a disguise.

Source: Introducing System One Models & Jev — TypeSafe AI