Jev in depth
How far can an AI that only returns decisions go?
Two weeks after launch, Jev is an ecosystem rather than a model. Official specs, the limitations TypeSafe publishes itself, an independent 821-item benchmark, routers and local runtimes, and the clones. We separate marketing from verified results.Oct 1, 2026
On September 15, 2026, TypeSafe AI released Jev — a model that generates no text and returns only typed decisions and probabilities. The name comes from Kahneman's "System 1" (fast thinking); the model is named after William Stanley Jevons, of the Jevons paradox, the idea that cheaper intelligence expands demand rather than shrinking it. Verified In the two weeks since, official docs, several independent tests and compatible clones have all appeared. This article puts them in one place, with marketing claims and verified results kept clearly apart.
- Verified Confirmed in official documentation
- Vendor claim Figures from TypeSafe's own evaluations, not independently reproduced
- Third-party test Measured independently by outside developers or press
- AIfrontier view Editorial interpretation
1. What it solves
Founder Diogo Almeida is an ex-OpenAI researcher who worked on the instruction-following research that led to ChatGPT. The question he says he carried for four years is why superhuman chat models have not led to automation. His answer is a category he calls System One models, with Jev as the first. Source: TypeSafe AI
The difference is in the output. A normal LLM generates text one token at a time, and your application has to parse and validate that string. Jev's possible outputs are defined in advance, and it answers every question in a single parallel pass. It trades text generation for speed and type safety.
| Question type | Goal | Returns |
|---|---|---|
| Choice | Pick one option from a list | The choice, a probability per option, and confidence |
| Score | Grade the state on a rubric | A score, a probability per level, and confidence |
| Noul | Is the statement true? | A probability of true (0–1) |
confidence collapses the shape of the probability distribution into one number; a Choice whose mass is split across options scores lower. The docs recommend a three-band pattern: act automatically at high confidence, ask for confirmation at medium, route to a human at low. Source: TypeSafe docs
2. Official specsVerified
| Item | Detail |
|---|---|
| Model | jev-1.13.0 (aliases jev-latest and jev-preview currently point to the same build) |
| Endpoint | POST /v1/systemone |
| Price | $0.042 per million input tokens ($42 per billion). Output is free |
| Rate limits | 100K tokens/s and 40 requests/s, with a note that limits adjust dynamically |
| Context | 64k tokens per request (state plus all questions); 32k for the state plus the single longest question |
| Input | Text only — string, JSON object or array. No image, audio or video |
| Customization | No per-account fine-tuning; all accounts share weights. Domain adaptation happens through state, instructions and criteria |
| Language | English is the primary training language and where accuracy is best. Other languages, including CJK, are handled but not equally well |
| Data | Customer inputs and outputs are not used for training; zero data retention is available for enterprise |
The language note matters. The docs explicitly tell you to test on your own content before relying on Jev for a non-English workload, and to watch confidence when routing. Source: TypeSafe docs
3. The claims — and the caveats TypeSafe publishes itself
The headline claims are these:Vendor claim
- Similar intelligence to existing LLMs on System One tasks, two orders of magnitude faster and more efficient
- End-to-end latency of 70–500 ms, against a cited third-party benchmark putting frontier LLMs at 3–329 seconds
- On its workflow evaluations, up to 193.6x faster and 444.6x cheaper, owning the Pareto frontier across roughly two orders of magnitude
- No type errors and a 0% tool-call error rate, because the schema is fixed in advance
- Playing Doom for an hour costs about $7 at 10 queries per second
Here is the part that matters most. In its own launch post, TypeSafe lists the weaknesses of its evidence, which is unusual for a product announcement and genuinely useful:
"These workflows were not deliberately chosen... However, they were made by individuals on our model capabilities team, so some bias could exist."
"We use the average of GPT-6 Astra and Fable 5.1 as the reference answer, which biases answers towards OpenAI and Anthropic's models."
"We can't prove it isn't subsidized; we'll need the long-term to prove the sustainability of our pricing."
In other words, the Pareto-frontier result comes from workflows written by the vendor's own team, run through the vendor's own wrapper, judged against an average of two rival models. It is a strong sales figure and it also needs independent reproduction. TypeSafe has published no technical paper and no training data — what it does publish is an evals site and an open-source adapter that constrains LLMs to Jev-compatible output.
4. Third-party tests: not "always smarter"Third-party test
A public test on Qiita ran 821 items — 200 each from four public datasets plus 21 hard cases — against jev-1.13.0, two small OpenAI models, and a local Qwen3.8 27B (Q4). Source: Qiita (third-party test)
| Dimension | Result |
|---|---|
| Latency | Median about 240 ms — 2.5–3.7x faster than the two OpenAI models, 6.2–8.5x faster than local Qwen3.8 |
| Cost | Per 1,000 items, 1/3.9 to 1/8.1 of gpt-5.4-nano and 1/6.3 to 1/12.7 of gpt-4.1-mini |
| Parallelism | Batching five questions into one call barely changed latency |
| Accuracy | Best on 77-class intent classification (0.790), but lost the English sarcasm dataset to local Qwen3.8 (0.870 vs 0.805) |
| Statistics | Apply a multiple-comparison correction to the 12 pairings and no significant differences remain |
The tester's conclusion: Jev is not "a classifier that is always smarter than an LLM," but a component that returns equivalent judgments several times faster and at a fraction of the cost, with calibrated probabilities.
Other reports point the same way. Forbes describes a Vercel engineer replacing a safety classifier with Jev, reporting higher accuracy and 5–18x faster responses. Another developer's business-email classification found Jev substantially cheaper than Gemini but slightly less accurate. TechCrunch reported that TypeSafe briefly could not keep up with API demand after launch. Source: Forbes JAPAN
A classmethod write-up frames the division of labour well: Jev is like "a type-safe, fast, cheap JSON mode," and it does not contain a thinking mechanism — context quality matters just as it does with an LLM. It fits high-frequency routing, agent guardrails and background stream monitoring; asking it to do heavy reasoning is an anti-pattern. Source: classmethod
5. The ecosystem, two weeks in
The model itself is still waitlisted early access, but the ways to call it — and the clones — multiplied quickly.Verified
| Kind | What appeared |
|---|---|
| Gateways | Vercel AI Gateway (Sep 16), Cloudflare Workers AI (typesafe/jev), and OpenRouter (callable from Sep 18) |
| Router | Jev Router on OpenRouter (Sep 25, free). Jev judges prompt difficulty and picks the model and reasoning effort; OpenRouter reports it completed 82% more tasks than its existing Auto Router. Prompts are not stored and attachments never reach Jev |
| Local | Ollama added decision-model support on Sep 29, following TypeSafe's API shape |
| Clones | Laya (Convai Innovations, Apache 2.0, 421M, multilingual router), Jeff (Qwen3.5 0.8B/2B and Gemma4-E2B — MIT code, Apache 2.0 weights, zero-shot classification, 22 ms per decision on an RTX PRO 6000), Kev (Qwen3.5/3.8, 0.8B–27B, Apache 2.0, Jev-compatible API) |
| The incumbent's answer | OpenAI's Decisions API (Sep 29, GPT-6 Luna, limited preview, image input) |
Jeff states plainly that it is unaffiliated with and unendorsed by TypeSafe, and publishes its recipe: trained on a single RTX PRO 6000 workstation, with synthetic data written by an open model (Qwen3.8-Flash-Next) on two DGX Sparks, tested on a MacBook, and no cloud GPUs at all. Its published benchmarks approach or beat Jev on classification and grounding, while trailing substantially on reasoning-heavy suites such as BBH — which it states itself. Source: GitHub / Jeff
Kev notes that no controlled comparison is possible without knowing what Jev was trained on, and reports that on unseen sources Kev-27B scores 0.851 against Jev's 0.857. It also documents a fine-tuning example: accuracy on a support workload rose from 67.7% to 73.6%, and the share of decisions automated at a 5% error budget rose from 34% to 48%. Source: GitHub / Kev
6. The nine failure modes TypeSafe publishesVerified
For anyone deciding whether to adopt this, the most valuable document is TypeSafe's own list of failure modes. Source: TypeSafe docs
| # | Where it fails | What to do instead |
|---|---|---|
| 1 | Reading intent — it reads the words you wrote, not the ones you meant | State the exact condition; put boundary cases in the criteria |
| 2 | Math and counting — errors grow with the size of the thing counted | Keep arithmetic and counting in code |
| 3 | Date comparison — it reads dates as text, not ordered quantities | Extract components with the model; compare in code |
| 4 | Indirection — double negatives and multi-hop references cost accuracy | Write instructions directly and point to the relevant state |
| 5 | Large states full of irrelevant detail | Filter in code first |
| 6 | Adversarial content — injected instructions can move the answer | Write precise criteria and test edge cases before deploying |
| 7 | Contradictory instructions and criteria | Align the two |
| 8 | Structural invariants — the same question asked two ways can disagree | Don't rely on identities between separate questions |
| 9 | Generation | Use a generative model |
Number 8 deserves emphasis. The docs show a worked example where the same ticket answers "is the customer asking for a refund?" at 0.22 as a Noul, but 0.01 as the "yes" option of a Choice — and warns against carrying a threshold tuned on a Noul over to a Choice, or holding the model to arithmetic identities between separate questions.
7. What to check before adoptingAIfrontier view
- Narrow the use case. High-frequency classification, routing, go/no-go checks and monitoring are the sweet spot. Leave long reasoning and writing to other models.
- Measure your own language. TypeSafe states that English is where accuracy is best. Establish accuracy and the confidence/accuracy relationship on your own documents before setting thresholds.
- Calibration does not transfer. Thresholds must be re-measured against your own labeled data — moving to Jev or away from it are the same problem.
- Structural dependency risk. No weights, no training data, no technical paper, and the vendor itself says its pricing sustainability is unproven. Keep an abstraction layer so a critical path can switch to another decision model.
- Measure the quality of errors. Track how many cases that should have gone to a human were automated, not just overall accuracy. A Choice distribution is exactly the input that rule needs.
Jev's contribution is not a smarter model but splitting out the decision layer in a form code can consume directly. Independent testing supports the speed and cost claims; it does not support a claim of consistently higher accuracy than general LLMs. What determines success is not the model's intelligence but how you decompose questions and how you use confidence.
Sources
- TypeSafe AI, "Introducing System One Models & Jev" https://typesafe.ai/blog/introducing-system-one-models-and-jev
- TypeSafe docs: Models / Confidence / Jev 1.13 failure modes https://docs.typesafe.ai/models , https://docs.typesafe.ai/confidence , https://docs.typesafe.ai/model-jaggedness/jev-1.13
- TypeSafe evals site https://evals.typesafe.ai/ and system-one-adapter https://github.com/typesafe-ai/system-one-adapter-python
- Qiita, independent 821-item comparison of Jev vs LLMs https://qiita.com/skrtk98/items/5c70baea21908705eb9f
- classmethod, using Jev from the SDK https://dev.classmethod.jp/articles/typesafe-ai-jev-architecture/
- Forbes JAPAN, "Jev: decisions software can use" https://forbesjapan.com/articles/detail/105325
- ITmedia @IT, why Jev removes hallucination and runs up to 200x faster https://atmarkit.itmedia.co.jp/ait/articles/2609/25/news055.html
- GIGAZINE: Jev (Sep 16) https://gigazine.net/news/20260916-system-one-jev/ ; Jeff (Sep 29) https://gigazine.net/news/20260929-jeff/ ; Jev Router (Sep 28) https://gigazine.net/news/20260928-openrouter-jev-router/
- OpenRouter, Jev Router https://openrouter.ai/typesafe/jev-router
- Ollama, decision-model support https://ollama.com/blog/ollama-now-supports-jev-style-decision-models
- GitHub: firelex/jeff, jaredpalmer/kev, denis-pplx/autojev