Owain Lewis walks through Jev, a "system one" model from Type AI that isn't an LLM: you send it a prompt and get back a typed, probability-scored answer instead of free text. He demos its three primitives (yes/no, choice, score) in Python, then shows real builds — support-ticket triage, an email classifier via Claude Code, a Codex model router, and a Bitcoin trading toy he admits is a bad fit. His verdict: at high volume it's dramatically cheaper and faster than an LLM (about $0.09 vs $14-29 to classify 5,000 emails), but not worth the added complexity for low-volume local work.
- Jev is not a large language model — it's a "system one" fast-decision model that returns a fixed schema with probabilities and confidence scores rather than generated text.
- The two use cases the presenter would actually reach for are routing and classification, both extremely common inside AI systems.
- The model exposes three primitives: a yes/no boolean (returns a 0-1 score, with 0.5 as the cutoff), a choice (pick one of a defined set of labelled categories), and a score (rate something on a spectrum, e.g. how blocked a customer is).
- Getting started needs an API key from either the Type AI console/playground or OpenRouter, plus the Type SDK in Python.
- A support-ticket demo classified a production outage as "engineering" and "critical" with 100% probability on both dimensions, showing the pattern for triaging tickets or GitHub issues.
- A Codex router skill combines a markdown skill file with a deterministic Python script that calls the Jev SDK, picking a high-reasoning model for a code review and a cheap low-reasoning model for a routine task.
- Cost comparison for classifying 5,000 emails: about $0.09 with Jev, around $2 with Claude Haiku, and $14-29 with Opus — the presenter calls it roughly a 30,000% difference.
- The honest caveat: for local, low-volume work just use an LLM; Jev only pays off when you're running thousands of classifications or routing decisions a day in production.
- He flags the Bitcoin buy/hold/sell trading demo as a bad use case, since deterministic code would do it more efficiently.
The concrete pricing and throughput numbers are the whole argument for using this model over an LLM.
You can see the cost of 5,000 emails with Jev is $0.09. Whereas with Haiku, this is going to be about $2... but then if you go up to something like Opus, you can see here we're paying like $14 to $29 to process these emails.
A working example of routing where Jev picks a high-reasoning model for code review and a cheap light model for a routine task, combining a skill file with deterministic code.
If you want to save money with AI, you want to spend less on tokens... you can use an intelligent router to choose which model to use for a particular task.
Jev is not a large language model. This is a completely different type of model.
I would say this is actually a bad use case for Jev because you could probably do this much more efficiently using deterministic code.
If you're just doing things on your local computer, you're not using this at high volume, it's probably not worth the complexity of adding something like Jev to your setup.