For the last couple of years, building with AI has meant one reflex: when you need a decision, you call a large language model. Is this email spam? Ask GPT. Which department should this ticket go to? Ask Claude. It works, but it has always been a slightly absurd arrangement. You are paying a system trained to write essays, poetry, and code to answer a yes or no question, and you wait a few seconds and parse a paragraph to get there.
Jev, a new model from TypeSafe AI, starts from the observation that a huge amount of what we call "AI" in software is not writing at all. It is deciding. And decisions, the argument goes, deserve their own kind of model.
The insight: most AI tasks are judgments, not essays
Think about where AI actually shows up inside a real product. Sorting support tickets. Flagging a risky transaction. Deciding whether a comment is spam. Tagging a lead as hot or cold. Checking whether a model's own output is safe to show. None of these need a sentence back. They need a verdict, ideally with a number attached so your code knows how much to trust it.
Using a chat model for this is like hiring a novelist to sit at a desk and tick checkboxes. They can do it, brilliantly even, but they are slow, they cost a fortune, and every so often they hand back a beautifully written checkbox that your program cannot read.
What Jev actually is: System 1, not System 2
The name is a nod to two things. It honours the economist William Stanley Jevons, and it borrows the framing of the psychologist Daniel Kahneman, who split human thinking into two modes. System 1 is fast, intuitive, and effortless, the snap judgment you make without deliberating. System 2 is slow, deliberate reasoning, the kind you use to work through a hard problem step by step.
Today's frontier language models, especially the reasoning ones that "think" before answering, are System 2 machines. They are extraordinary at deliberation, and they charge you for it in time and money. Jev is deliberately the opposite: a System-1 model, built to make a fast, bounded judgment and return it immediately. TypeSafe's co-founder, Diogo Almeida, who worked on the original ChatGPT, argues that most decisions inside software never needed the slow, deliberate machinery in the first place.
The three things it can hand back
Jev does not produce open text. Every response is one of three structured shapes, and that constraint is the whole point:
- A yes/no, which TypeSafe calls a Noul. You get a single probability between 0 and 1, for example a 0.94 chance that an email is an invoice.
- A choice, where the model picks one option from a list you define, and returns the full probability spread across the options plus a confidence value. You can define up to 255 possible categories.
- A score, a number on an ordered scale you set up, from 2 to 10 levels. You get back a weighted average, the probability on each level, and a confidence.
Because the answer can only ever be one of these predefined values, your program always receives something it can act on directly, with no parsing and no guesswork.
Why it is so fast: it decides in one pass, not one token at a time
Here is the technical heart of it. A language model is autoregressive: it generates its answer one token at a time, and each token it produces is fed back in as context for the next one. That sequential dependency is why generation takes seconds, and it is also how small early mistakes snowball into confident nonsense later in the sentence.
Jev is non-autoregressive. It uses a parallel sampler that evaluates the question and produces the decision in a single pass, with no token-by-token loop. When you ask it several questions about the same input, it answers them independently and in parallel, so one answer never becomes the context that corrupts another. Strip out the sequential generation and the latency largely disappears.
The result, on TypeSafe's published figures, is end-to-end responses in roughly 70 to 500 milliseconds, with most landing near 100. That is fast enough to sit inside a live interaction rather than a background job.
Why it "never hallucinates" (and the honest asterisk)
This claim gets repeated a lot, so it is worth being precise. A language model can return text that does not match the format you asked for: broken JSON, a category you never offered, a made-up field. Those structured-output errors are a real and constant headache, and depending on the model they happen anywhere from occasionally to nearly half the time.
Jev cannot do this. Its output is mechanically constrained to the options you defined, so a malformed or out-of-schema answer is not merely unlikely, it is impossible. TypeSafe reports a 0% structured-output error rate, against a range of 0.58% to 45.5% for the language models it compared against.
The honest asterisk: this does not mean Jev is always right. It means a wrong decision and a broken response are now two separate problems. It can still classify an email incorrectly. What it will never do is hand your code a value your code cannot understand, which is a genuinely useful guarantee when you are automating at scale.
The quietly important part: calibration
The feature that makes Jev safe to build on is not raw accuracy, it is calibration. TypeSafe trained it with a method they call Reinforcement Learning for Calibrated Decisions, or RLCD, which optimises the model so that its stated probabilities actually match reality. If Jev says it is 90% confident across a thousand decisions, it should be right on about 900 of them.
This matters because standard language models are notoriously overconfident. Ask one how sure it is and it will often say 95% whether it is right or wrong. Jev's probabilities are meant to be trustworthy enough that you can set a threshold and act on it: auto-approve anything above 0.95, send anything below 0.7 to a human or a bigger model, and handle the messy middle deliberately. Calibration is what turns a classifier into something you can wire into an automated workflow without holding your breath.
The numbers, side by side
TypeSafe benchmarked Jev on a four-workflow suite covering security, observability, invoices, and customer service. Here is how it stacks up on their own figures:
| Jev | GPT-5.6 Terra | Top frontier models | |
|---|---|---|---|
| Accuracy | 67.8% | 67.9% | 73 to 74% |
| Latency | 70 to 500 ms | seconds | 10 to 38 s |
| Cost per decision | about $0.0004 | far higher | $0.08 to $0.18 per case |
| Output format errors | 0% | some | 0.6% to 45% |
The reading is clear and also honest: Jev is not the most accurate model in the room. The very best frontier models are still about five to six points ahead on getting the answer right. What Jev offers is nearly the same accuracy as a mid-tier model at a tiny fraction of the cost and latency, with a hard guarantee on format. For a lot of high-volume decisions, that trade is very attractive.
Where it shines: real use cases
In early testing, the pattern that emerges is high-volume, bounded classification:
| Task | Roughly |
|---|---|
| Classify 1,000 emails against 7 rules (invoice, phishing, urgency, sponsor fit) | about 6 seconds for $0.09, versus 5 minutes and $0.62 for a chat model |
| Sort 1,000 YouTube comments by type, sentiment, and reply-worthiness | about 5 seconds for $0.05 |
| Label a live social feed in a browser extension (breaking, useful, or slop) | fast enough to tag posts as they load |
| Score and route support tickets across millions of items | real-time, at a fraction of a cent each |
| Guardrail another model's output before it reaches a user | a fast safety check in the request path |
One demo even had Jev making reactive decisions about ten times a second to play a game, at a few dollars an hour, the kind of latency and cost profile that multi-second language model calls simply cannot reach.
The pattern that actually matters: triage cheap, escalate rarely
The most useful way to think about Jev is not as a replacement for GPT or Claude, but as a cheap front door in front of them.
You let Jev classify everything, ten thousand emails, every ticket, the whole comment stream, in seconds for pennies. Most of those items just need a decision: route it, tag it, filter it, score it, done. Only the small remainder that genuinely needs words, a real reply, an explanation, a judgment call the model was not confident about, gets escalated to a full language model. The cheap layer handles the volume, the expensive layer handles the nuance, and your bill and your latency both collapse.
The honest limitations
Jev is narrow by design, and it is early. Worth knowing before you plan around it:
- It cannot write, explain, or reason. No prose, no summaries, no rationale. If you need an audit trail that explains why a decision was made, a bare probability will not satisfy a compliance reviewer.
- You must know the options up front. Jev only works when you can define the categories, the scale, or the yes/no question in advance. It is useless for anything open-ended.
- The benchmarks are the vendor's own. The speed and accuracy figures come from TypeSafe, and the reference answers were partly generated by OpenAI and Anthropic models. Independent evaluation is still pending, so keep a little salt handy.
- The pricing may be subsidised. TypeSafe has acknowledged the early pricing might not reflect the true long-term cost, so today's economics could shift.
- It is text-only and gated. No images, audio, or video, a shared budget of roughly 64,000 tokens, and access is behind an early-access waitlist as of September 2026, reachable through TypeSafe directly and via gateways like Vercel's AI SDK and OpenRouter.
The bigger picture: the unbundling of the LLM
Whether or not Jev specifically wins, it points at something real. The industry spent two years treating one giant, general model as the answer to every problem, because it was the only tool that worked at all. That era is ending. We are starting to split the workload into the right tool for each job: reasoning models for hard, deliberate thinking, small specialised models for on-device work, and now decision models for the enormous volume of fast judgments that never needed an essay in the first place.
If you are building AI into a product, the practical takeaway is simple. Look at where you are calling a language model and getting back a single label or a yes or no. That is exactly the work a System-1 model is built to do faster, cheaper, and more reliably, and it frees your expensive model to do the thing only it can: actually write.
If you want to see the token-by-token machinery that Jev deliberately avoids, our companion piece lets you run a real transformer live in your browser and watch it generate one token at a time.
Sources
- TypeSafe AI, the makers of Jev
- Jev: TypeSafe's System One Model That Never Hallucinates, DataCamp
- A deep dive into Jev, Flavio Copes
- Jev use cases and automation, MindStudio
- What is Jev? A guide to TypeSafe AI's System One model, LangChain
- Daniel Kahneman, Thinking, Fast and Slow, the System 1 and System 2 framing
Frequently asked questions
- What is Jev AI?
- Jev is a decision-only AI model from TypeSafe AI, described as a System-1 model. Instead of writing text like a chatbot, it takes an input and returns one structured decision: a yes/no answer with a probability, a category chosen from a fixed list, or a numeric score on a scale. It is built for high-volume, bounded decisions in software, such as classifying, routing, filtering, and scoring, where a full language model is slow and expensive overkill.
- How is Jev different from an LLM like GPT or Claude?
- A language model writes an answer one token at a time, where each token becomes the context for the next, which is why it is slow and can drift or hallucinate. Jev is non-autoregressive: it samples a single decision in one parallel pass, so there is no token-by-token generation. It only ever returns a value from a predefined schema, and every answer comes with a calibrated probability. It cannot write prose or explain itself, which is the trade-off.
- Does Jev really never hallucinate?
- Not in the structural sense. Because every output is constrained to a predefined option, a yes/no, a category, or a score, Jev cannot return a malformed or out-of-schema answer, and TypeSafe reports a 0% structured-output error rate. It can still be wrong about a decision, but a wrong decision and a malformed response become two separate problems, which is much easier to handle in code than free text that might be invalid.
- How much faster and cheaper is Jev than an LLM?
- On TypeSafe's own classification evaluations, Jev is reported as roughly 20 to 200 times faster and 40 to 400 times cheaper than frontier language models, with end-to-end latency of about 70 to 500 milliseconds and input priced near $0.042 per million tokens with output unmetered. These are the vendor's published numbers and have not yet been independently reproduced, so treat them as promising rather than settled.
- When should I use Jev instead of a language model?
- Use Jev when the task is a bounded decision made at high volume: classifying emails or tickets, filtering comments, scoring reviews, routing, or guardrailing another model's output. Use a language model when you need writing, explanation, summarisation, reasoning, or open-ended conversation. The strongest pattern is to combine them: let Jev cheaply triage everything, then send only the small subset that needs words to GPT or Claude.