Every agent framework I've wired up this year assumes the same contract: send tokens in, get tokens out, parse the string, validate it, hope. TypeSafe AI's Jev breaks that contract on purpose.
Diogo Almeida, the founder, published the launch post on 15 September 2026. Jev is the first "System One Model" — a class of model that emits type-safe structured values instead of strings, tuned with a training method TypeSafe calls Reinforcement Learning for Calibrated Decisions (RLCD) rather than RLHF or RLVR. The name comes from Kahneman's fast/slow split; Jev is named after William Stanley Jevons, via the coal-demand argument.
What The API Actually Returns
The output schema is defined in advance. The model fills in a value per key, and every value ships with a calibrated probability and confidence score. TypeSafe's claim is that this makes type errors mathematically impossible rather than empirically rare — you cannot get a string back where an enum was declared, and you cannot get a hallucinated tool call, because there is no free-text channel for one to travel through.
The sampling story explains the latency. LLMs generate one token at a time, each conditioned on the last. Jev generates all outputs in a single query — the post calls the sampler "parallel" and "hardware-aware." That is the entire reason the numbers below look the way they do.
The Numbers TypeSafe Published
| Existing LLMs | System One + Jev | |
|---|---|---|
| Optimized with | RLHF / RLVR | RLCD |
| Output | Strings, parsed + validated | Type-safe structured values |
| Sampling | Sequential, one token at a time | Parallel, single query |
| Input cost | $0.20 – $10 / MTok | $0.042 / MTok ($42 per billion tokens) |
| Output cost | ~5x input tokens | Free |
| End-to-end latency | 3 – 329 seconds (frontier models) | 70 ms – 500 ms |
Against LLMs constrained to the same structured output via the System One adapter, TypeSafe reports 193.6x faster and 444.6x cheaper on their workflow evals. That is the number on their home page, and they flag it themselves as likely the optimistic end of real-world gains.
Where The Workflow Eval Comes From
The eval design is the part worth copying. Instead of scoring against a ground-truth label, they define a fixed compute graph — a workflow expressed in code — and use the average of GPT-6 Astra and Fable 5.1 as the reference probability distribution. Every model gets the identical workflow; no harness engineering, no prompt-tuning arms race. TypeSafe's published caveats: the workflows were authored by their own capabilities team (bias possible), the two reference models are both OpenAI and Anthropic (which likely understates Jev's relative edge), and the calls are materially more complex than the side-by-side playground demo.
The eval site is evals.typesafe.ai with full queries, disagreement lists, and all four workflows.
What I'd Actually Use It For
The intended shape is a fuzzy if-statement. Classify, route, score, extract, branch — the places where hand-written logic breaks on edge cases and an LLM is too slow or too flaky to sit in the request path. 100ms responses mean you can put the call inside a product interaction rather than a background job. Two published demos make the point: a Doom bot running 10 queries per second at roughly $7/hour, and a Wikiracing agent where the step function picks among hundreds to thousands of links — the high-cardinality case where one hallucination ruins the run.
Caveats I would carry into a pilot:
- No reasoning. Jev is a System 1 model; there is no chain-of-thought to extend when a call is genuinely hard. That is the point of it, and also the limit.
- Early access, West Coast service. The published latencies were measured from TypeSafe's laptops in that region. Everything I run is from Oslo, so I'd measure before trusting the 70ms floor.
- Jev's cardinality caps at 255. Above that they fall back to a two-stage system — score independently, then make an explicit choice — which is where the occasional slowdown in the Wikiracing demo came from.
- Not an LLM replacement. Strings are still how you write prose, code, and explanations. Jev replaces the classification call hiding inside your agent loop, not the agent.
If you already run agent traffic through a structured-output adapter like the GitHub Copilot SDK path in MAF v1.0, the integration shape is not foreign — but the pricing asymmetry is, and it is the reason to look. Output tokens are free; input is $0.042 per million. For a workload doing map-reduce over a corpus, that changes the arithmetic of whether the AI call belongs in the pipeline at all.
Sources: