Jev, Explained: A New AI Model That Doesn't Write Text

TypeSafe's first model doesn't write anything. It picks, it scores, and it says how sure it is. The pitch is 193x faster and 444x cheaper. The company's own numbers are smaller than that, and more interesting.

TypeSafe AI came out of stealth on 15 September with a new model class and one model in it. The class is System One Models, the model is Jev. Waitlist only, no download, no chat window. The founder is Diogo Almeida, who worked on instruction-following research at OpenAI before going quiet for two years.

What Jev actually is

There's no text generation anywhere in it. You hand Jev two things: some state, which in the docs means anything from an email to a log line to a support ticket to a JSON object, and a set of questions whose possible answers you defined in advance. It returns answers and probabilities and nothing else.

Questions come in three shapes, and the docs are explicit that these are all of them:

Noul — yes or no, returned as a probability. "Does this message request a refund?" comes back as noul: 0.95.
Choice — one option from a set you supply, plus a distribution over the set. "Which team should handle this ticket?" run against billing, technical, account.
Score — a level on a scale, with a distribution and a confidence figure. "How frustrated is this customer?" on 0 = calm, 1 = frustrated, 2 = very frustrated, returning 1.4.

Those examples are TypeSafe's own, and they're illustrative rather than measured. What matters is the shape. Answer spaces are fixed before the call, so there's no prose to parse and no reasoning to read. If you want to know why it said 1.4, there's nowhere to look.

Every answer comes back in a single parallel pass rather than one token at a time. The endpoint is POST /v1/systemone, with Python and JavaScript SDKs and a jev-latest alias. Input is text only. Pricing is $0.042 per million input tokens with output billed at nothing. The name is Kahneman's, and it's a fair one: this is the fast, intuitive half of the system, deliberately kept away from the deliberate half.

What it's for

TypeSafe's own framing is "smart if-statements." Fuzzy decision rules that slot into ordinary code where hand-written logic is too brittle.

Routing and triage. Sort inbound tickets, alerts or claims into a queue. The cleanest fit, because the answer space is small and a mistake gets caught by a human downstream.
Scoring and grading. Rubric checks, moderation severity, lead quality. Good Start Labs regraded 6,003 rubric checks with it, the largest public use I've found.
Extraction and classification. Pull typed fields out of unstructured text without a parse-retry loop.
Verification of model output. TypeSafe lists scoring, judging, guardrailing and jailbreak detection of LLM prompts and outputs. Plausible niche, one caveat below.
Real-time paths. Frontier models run 3 to 329 seconds end to end, and nothing sitting in a request path absorbs that. 70 to 500ms does.

The docs walk a refund case: build a state from the customer message, the transactions and the policy; ask in one pass whether a refund was requested, whether the evidence shows a duplicate charge, and whether policy supports one; then combine those answers with deterministic checks in code and route for action or review. That's the shape of every real integration. The model isn't making the decision, it's supplying fuzzy inputs to a decision your code already makes.

What's out of scope follows from the design. Anything needing prose back, anything open-ended, anything that requires an argument.

How it differs from an LLM

Less like a smaller, cheaper chat model, more like a different output contract.

Training objective. LLMs are optimized with RLHF, for write ups human raters prefer, or RLVR, for outputs that can be programmatically verified. Jev uses RLCD, Reinforcement Learning for Calibrated Decisions, which optimizes for answers with honest probabilities on decision-shaped tasks.
Output. An LLM emits a string, flexible enough to be anything including a refusal or a hallucination, and your code has to parse and validate it. Jev emits a typed value from an answer space fixed in advance.
Sampling. Sequential, token by token, each conditioned on the last, versus parallel in one query. Nearly everything about the pricing and the latency falls out of that single difference.
Cost shape. LLM input runs $0.20 to $10 per million tokens with output at roughly 5x input. Jev is $0.042 in and nothing out. The expensive half of an LLM bill is the half Jev doesn't have.
Confidence. Prompt an LLM for a confidence estimate and you get an overconfident, inconsistent one. If a model is right 95% of the time and can't tell you which 5% is wrong, you can't automate the task. Jev ships a probability with every answer, and the claim is that higher confidence means higher accuracy.

The docs put the honest boundary on that last one directly:

Calibration is measured across groups of predictions; it does not guarantee that an individual answer is correct.

A probability is a statement about a population of calls, and the call in front of you is one draw from it. The difference people will notice first at work is the missing loop. If you've wired structured output into a chat model you've written the schema validation, the retries, the guard against refusals and invented tool calls, and the timeout handling for the tail. Here schema compliance is structural, so that code goes away. What doesn't go away is checking whether the valid answer was the right one.

The numbers don't agree

On launch day, depending on where you looked, you got three different multipliers. The homepage said 193.6x faster and 444.6x cheaper. The launch blog said 40x–200x, qualified "for System One shaped queries." The founder's thread said 20–200x faster and 40–400x cheaper. TypeSafe attributes the homepage pair to its workflow evals and adds that it expects those to land "on the higher end of real world gains," which is a candid hedge and a quiet admission that 193.6x isn't a general multiplier.

The homepage then sets two figures next to each other that don't measure the same thing: $0.000081 finished in 0.114s, against $0.013880 in 8.566s. Divide the times and you get about 75x. Nothing on the page marks those as different workloads, so 193.6x and 75x share a screen and only one is arithmetic you can check.

The eval is more honest than most launch benchmarks and still not what it looks like. Every model runs the identical workflow at evals.typesafe.ai, but the reference is the average of GPT-6 Astra and Claude Fable 5.1 at high thinking. So a Jev score tells you how closely Jev agrees with two frontier models, not how often Jev is right. TypeSafe says plainly that the method biases answers toward OpenAI and Anthropic models, and that the workflows were written by their own capabilities team. Aggregate across their four published workflows:

Jev: 67.8% accuracy, $0.0004/case, 0.4s
Claude Opus 5: 73.1%, $0.1761/case, 37.8s
Sol: 74.1%, $0.0836/case, 23.3s
Terra: 67.9%, $0.0304/case, 10.1s
DeepSeek V4 Flash: 64.4%, $0.0059/case, 51.9s

Jev trails Opus 5 by 5.3 points and is something like 440x cheaper and 95x faster per case. Against Sol it's 6.3 points down and about 209x cheaper. So the real headline is that a model giving up text generation entirely lands within a few points of frontier models on decision-shaped work, at two to three orders of magnitude less cost. That's a notable result, and it isn't the one the homepage is advertising.

The outside tests are narrower and I trust them more. Near Here, a UK events company, ran 50 real listing-moderation decisions through jev-1.13.0 and got 96% accuracy, against 84% for Mistral Small 4 and 86% for Gemini 3.5 Flash-Lite, at 0.59s per decision. Against Mistral that's about 5x faster and 8.6x cheaper. Good Start Labs regraded 6,003 rubric checks across 1,203 financial-research answers: 91.5% agreement with Fable 5.1, about $160 per million graded answers versus roughly $260 for DeepSeek V4.1 Flash, a 1.6x cost edge. Every measured 0.35s per passage against 8.83s for Fable 5.1, with Jev catching six of the seven planted defects Fable caught all seven of. And a TypeSafe employee's own DSPy integration, swapping a single decision step, came out 15.9% faster and 30.1% cheaper end to end across three test cases.

Add it up and independent measurements run somewhere between 1.6x and 8.6x. For a two-year-old company that's a real result. It's also two orders of magnitude from the claim.

Where that leaves it

Jev is the most interesting release this month and the least fairly sold. The real news is the trade itself: give up string generation and you get parallel sampling, typed output, and a per-decision cost low enough to put a model inside a hot path.

The launch says Jev can't hallucinate, and separately that type errors are mathematically impossible. Both are true, and neither means what you'd assume. Jev can't return something outside your schema. It can return the wrong thing from inside your schema, confidently. Type safety covers shape here, not truth, and the footnote under their 0%-hallucination chart says so:

Our number is not empirical. Schema matching is guaranteed, thus we can confidently add 0% into the plots.

Calibration is what TypeSafe trains for, what they named the method after, and the load-bearing claim in the whole argument. I went looking for a calibration curve, an expected-calibration-error figure, a paper. There isn't one published, Jev isn't downloadable, and nobody outside has posted an independent latency or billing measurement yet. The one claim that turns this from a product into a category is the one an outsider currently has to take on faith.

So: try it for the cost and the latency, keep it on the decision-shaped work it was built for, set the escalation threshold well below where you'd like it, and keep a fallback wired up for confident wrong answers. Nothing about a value being well-typed makes it correct.

Sources: TypeSafe AI launch post, homepage, and docs (System One, primitives, patterns); workflow evals at evals.typesafe.ai; The Cherry Creek News claim-by-claim audit; Hacker News thread 49717558; Good Start Labs' regrade of 6,003 rubric checks; Near Here and Every figures as reported in the Cherry Creek audit; Nic de Ville's notes.