Engineering
What Is Jev? TypeSafe AI's Decision-Only Model Explained
Updated Muhammad Taha9 min read
Jev is a "System One" model from TypeSafe AI that never writes text. You send it some text plus questions with fixed answers, and it returns the best option, a probability for each option and a confidence score. TypeSafe announced it on 15 September 2026 and claims it is far faster and cheaper than asking a chat model to make the same decision.
Key takeaways
- Jev is built for one job: picking from options you define. It does not draft, summarise, reason aloud or write code.
- Every answer comes with a probability and a confidence score. Your own code decides what to do with them.
- Reported pricing is $0.042 per million input tokens with free output, and responses in roughly 70 to 500 milliseconds.
- The benchmarks come from TypeSafe itself and use large-model answers as the reference, so treat them as a starting point, not proof.
- The sensible first test is re-labelling data you have already labelled by hand and comparing the results.
What is Jev?
TypeSafe calls Jev a "System One" model. The name comes from Daniel Kahneman's book Thinking, Fast and Slow, where System 1 is fast, intuitive thinking and System 2 is slow, deliberate thinking. Jev is built for the fast kind only.
In practice it has one job. You give it a piece of text and a set of questions that have predefined answers. It tells you which answer fits, how likely each option is and how confident it is overall. There is no stream of output tokens at all.
The founder is Diogo Almeida, who previously worked on ChatGPT at OpenAI. TypeSafe describes its training method as RLCD, short for Reinforcement Learning for Calibrated Decisions. The pitch is that chat models became very good at talking and stayed surprisingly poor at deciding, and that a model built only for decisions can be many times faster and cheaper than asking a large language model to do the same thing. The name nods to the Jevons paradox: when William Stanley Jevons noted in 1865 that more efficient steam engines increased Britain's coal use, he showed that cheaper inputs can raise total consumption. If a decision costs almost nothing, software makes far more of them.
How a Jev call works
Each request has two parts: a state, which is the text to be judged, and one or more questions about it. There are three question types.
| Type | What it does | What you get back |
|---|---|---|
| Choice | Picks one option from a list you define | The pick, a probability per option and a confidence score |
| Score | Places the input on an ordered scale such as low, medium, high | Same outputs as Choice |
| Noul (TypeSafe's term) | Checks whether a statement is true | One probability between 0 and 1 |
One call can mix all three, and Jev answers them in parallel against the same state. That is why the economics work: asking 60 questions costs about the same as asking one. Here is a rough example. A customer writes: "Your API has been returning 502s since last night and our checkout page is down. We're a paying customer, please fix this today."
{
"state": "Your API has been returning 502s since last night...",
"questions": {
"team": {
"type": "choice",
"instructions": "Which team should own this ticket",
"criteria": {
"engineering": "Bugs, outages, integration failures",
"billing": "Payments, invoices, subscriptions",
"sales": "Pricing and plan questions"
}
},
"severity": {
"type": "score",
"instructions": "How severe is the customer impact",
"levels": ["low", "medium", "high"]
},
"needs_human_now": {
"type": "noul",
"instructions": "This message requires a human response within the hour"
}
}
}You would get back something like: team = engineering at 0.94, severity = high, needs_human_now = 0.97, each with a confidence attached. Your code then does whatever it wants with those numbers.
One gotcha from the documentation: the question IDs (like needs_human_now) never reach the model. Only the instructions text does, so write the full question in the instructions field or the results will look strange.
Why the confidence score matters more than the answer
Most write-ups skip this, and it decides whether Jev is useful to you. Jev can return an answer with a high probability and a low confidence at the same time. That happens when the top option gets most of the weight but a second option gets a meaningful share too. The probabilities say what it picked. The confidence says how far to trust the pick.
The intended pattern is simple. Act automatically on confident answers. Send unsure ones to a person or to a larger model. Your code owns the threshold, so control stays in ordinary software and the model only supplies a probability. That is the same control principle we describe for human-in-the-loop agents and for agent guardrails.
What does Jev cost and how fast is it?
| Item | Reported figure |
|---|---|
| Input price | $0.042 per million tokens |
| Output price | Free, because there is no generated output |
| Latency | About 70 to 500 milliseconds |
| Rate limits | 250,000 tokens per second and 1,200 requests per minute |
| Context | 64k tokens per request |
TypeSafe published evaluations across four agent workflows. Its numbers put Jev at 67.8% accuracy, level with Claude Sonnet 5, at about $0.0004 per case against $0.1174 for Sonnet 5, and 0.4 seconds against 78 seconds. Opus 5 scored higher at 73.1% but cost $0.1761 per case.
Two caveats, both acknowledged by TypeSafe. The reference answers were produced by two large reasoning models, not by humans, so "67.8% accuracy" means "agrees with those two models 67.8% of the time". And the vendor chose the workflows. Pricing and latency have been reported by outlets such as DigitalOcean, but independent accuracy testing is still thin, so run your own.
What are people building with it?
The madewithjev.com directory listed close to 300 projects within a week of launch. Most fit one of four shapes:
- Choosing the next action in an agent loop. An LLM proposes candidate actions, Jev picks one, code runs it.
- Sorting a queue into buckets. Support tickets, leads, moderation flags, research papers.
- Scoring every item in a large set. One developer reported classifying 1,018 AI research papers into 24 topics for $0.08, with about $4 spent on the LLM summaries that fed into Jev.
- Gating a risky step. Before an agent runs a shell command or sends an email, ask Jev whether it looks dangerous and block anything below a confidence threshold.
There are also "instant" cases, such as scoring tool-call history to decide what to drop during context compaction, or a browser agent that reportedly found flights in 7 seconds for $0.004 by using Jev to pick from the page at each step. The shared pattern, where an LLM writes, Jev decides and code acts, is what people now call Jev Engineering.
Where Jev does not fit
- It does not generate anything. Drafts, summaries, code and explanations still need an LLM.
- It only takes text. Strings, JSON objects and lists of strings. No images, audio or video yet.
- You define every answer up front, and a Choice question caps at 255 options.
- "Cannot hallucinate" has a narrow meaning. Jev cannot return an option outside your schema, so you never get malformed JSON or an invented field. It can still pick the wrong valid option. Type safety prevents broken outputs, not bad judgement.
- Dependent questions run one after another. Parallelism only applies to independent questions.
- Calibration is an open question. At least one ML engineer who tested it reported that the confidence scores were not well calibrated out of the box. Run your own data through it and choose thresholds empirically, rather than trusting that 0.8 means the same thing across tasks.
Is Jev actually new?
Partly. The idea of cheap, typed decisions is not new, but the combination is.
| Approach | Strength | Weakness |
|---|---|---|
| LLM with structured outputs | Flexible and can explain its reasoning | Slower and more expensive per decision |
| Small fine-tuned classifier | Very fast and cheap once trained | Needs labelled data and retraining when categories change |
| Zero-shot classifier | No training data needed | Weaker on nuanced, business-specific questions |
| Jev | Natural-language questions, parallel answers, sub-second latency and a very low price | Vendor-reported accuracy, text only, no explanations |
One senior backend engineer described it in a widely shared post as a very smart switch statement: what 2016-era classifiers might have been with 2026-level language understanding. Whether that makes it a breakthrough or simply a very good product is something nobody can settle yet.
How to test Jev in an afternoon
- Pick one decision you already make with an LLM, such as routing tickets or tagging leads.
- Collect 200 to 500 examples that people have already labelled by hand.
- Write the questions carefully, remembering that only the instructions text reaches the model.
- Compare Jev with your current method on accuracy, cost per case and speed.
- Plot accuracy against confidence to find the threshold where automatic action is safe, and send everything below it to a person.
- Keep your existing system running in parallel until the numbers hold up on live traffic.
Should you try it?
If a workflow uses an LLM to produce a category, a yes/no or a rank, and you pay per output token to get it, Jev is worth an afternoon. If your problem needs open-ended text, multi-step reasoning or non-text inputs, keep using an LLM. Jev was never meant to replace it. For help judging where a cheap decision model fits inside a larger system, see our guide to choosing an LLM for your business.
Availability and terms may change. Sources disagree on whether access is open or still an early-access waitlist, so check TypeSafe's site for the current position.
Related guides
- AI Agent Guardrails: Keeping Agents Safe in Production
- How AI Agents Use Tools: Function Calling Explained
- How to Choose an LLM for Your Business: GPT, Claude or Gemini?
- LLM API Cost Control for SaaS: Caching, Routing and Limits That Protect Your Margin
- Service: AI Workflow Automation
Frequently asked questions
What is a System One model?
A model built for fast decisions that other software calls directly. It does not write text or show its reasoning.
Can Jev hallucinate?
It cannot return a value outside the type you asked for, so it never invents an option. It can still choose the wrong option, so use the confidence score and test on your own data.
How much does Jev cost?
Reported pricing is $0.042 per million input tokens, with output free.
Does Jev replace ChatGPT or Claude?
No. It handles repeated small decisions. A larger model still does the writing and open-ended reasoning.
How do I call Jev?
With a single POST request to TypeSafe's API, or through its Python and JavaScript SDKs. A playground lets you try questions without code.
What is Jev Engineering?
A design pattern where a language model writes, Jev decides, and ordinary code acts on the decision.
Sources and further reading
Primary documentation and research behind this guide.