Jev and System One models - a semantic if statement for your code

Canonical version: Jev and System One models - a semantic if statement for your code.

Think about the last AI agent or automation you built. How many of its LLM calls were actually decisions? Is this email urgent? Which tool should I call? Is this paragraph off-topic? Is the agent stuck?

For each of those, we pay a text generator to write an answer as JSON, then we parse it, validate it, and retry when it breaks. On 15 September 2026, TypeSafe AI launched Jev, a model built to skip all of that. It never writes a single word. It only decides.

In this piece, I'll explain what Jev is, what people already build with it, the criticism, and the open-source alternatives that showed up within days.

What Jev does

You give Jev some state (a text, a list of texts, or name/value pairs) and typed questions. It gives you numbers back:

• Choice: a probability for each option you provide (a switch)
• Noulli: a yes/no probability (an if)
• Score: a value along a range you describe (sorting or thresholding)

The state is read once, and all your questions run against it in parallel. Ten questions about one support ticket cost you roughly one ticket. The output is typed by construction, so malformed JSON simply can't happen. And the probabilities are trained to be calibrated: when Jev says 80%, it should be right about 80% of the time. That's what lets you set real thresholds ("send it to a human below 0.7").

The numbers are wild. $0.042 per million input tokens, output free, 70 to 500 ms per batch of questions. Every measured it at 25x faster and 600x cheaper than a Fable 5.1-level judge. Matthew Berman categorized 724 ads in 40 seconds for 9 cents.

TypeSafe calls this category System One Models, after Daniel Kahneman's fast, intuitive System 1 (LLMs being the slow, deliberate System 2). I prefer the more generic term decision models, because the idea isn't new: classifiers, rerankers and zero-shot labelers have been making decisions for years. What's new is the generality. Arbitrary questions, arbitrary options, no training, quality close to a frontier LLM.

What people build with it

Nate B. Jones grouped the early builds into four patterns:

1. Add interpretation to an existing workflow: 70,000 insurance tickets categorized, new ones flowing through the same pipeline
2. Ask new questions of old data: eight questions applied to 3,282 social posts
3. Decide where deeper reasoning is worth spending: Jev flags what matters, an LLM handles the few hard cases. One developer halved his agent's costs by letting Jev pick the reasoning effort per step
4. Give small elements their own judgment: a prose linter asking ten yes/no questions per paragraph

My favorite example is fast-jev-compaction, a Claude Code plugin that compacts a session by letting Jev score each tool call instead of writing a summary. Alex Volkov showed a session going from about 1M tokens to 86K in about a second.

The criticism

• It's a black box. You get a number, not a reason. Simon Willison tested it on rating Bay Area cities and got results that raise obvious bias questions. His advice: you need MORE evals with a model like this, not fewer
• Known weak spots. TypeSafe's own docs admit it struggles with numbers, dates and adversarial content. If the answer isn't in your list of options, it will still confidently pick one
• Closed. API only, a waitlist, no paper, no weights, and the terms forbid publishing benchmarks. That didn't go down well on Hacker News
• Is it even new? Laya published a very similar model in March 2025 and started trending on Hugging Face right after Jev's launch

Open alternatives, within days

This is the part I love. The open-source community rebuilt the interface almost immediately: SemIf (formerly OpenJev) reads answer probabilities straight from a local model, Kev by Jared Palmer offers open models with a Jev-compatible API, and Jevlike is a small scorer you can train on a CPU. They're behind Jev on quality, but Kev-9B is already close on the tests people ran.

My take

I think Jev matters less as a model than as a new building block. We had code (cheap, deterministic) and LLMs (flexible, slow, expensive). Decision models sit in between: a semantic if you can afford to call thousands of times. That changes which ideas are worth building.

I'd use it for triage, routing, filtering and agent guardrails, where a wrong call is cheap and gets caught downstream. For anything consequential, I'd keep an LLM or a human in the loop. And I really hope the open models close the gap, because a decision layer this central shouldn't live behind a single closed API.

Want to go deeper? Check out my notes on Jev and Decision Models (DMs).

That's it for today! ✨

References

• Introducing System One Models & Jev (TypeSafe AI): https://typesafe.ai/blog/introducing-system-one-models-and-jev
• Simon Willison's notes: https://simonwillison.net/2026/Sep/21/jev/
• Nate B. Jones' build patterns: https://x.com/natebjones/status/2101421649774236145
• Jev's architecture unmasked (Archer Hume): https://archerhume.com/posts/jevs-architecture-unmasked/
• Open-source Jev alternatives (Apidog): https://apidog.com/blog/openjev-open-source-jev-alternatives/
• awesome-jev: https://github.com/Amal-David/awesome-jev

Related

• Jev
• Decision Models (DMs)
• System One Models
• TypeSafe AI
• SemIf
• Kev
• Laya

About Sébastien

Ready to get to the next level?