What is Jev, and why is everyone talking about it?
How is Jev deterministic, and how does that make it especially useful ?
Tuesday the 15th of September, Typesafe.ai launched its model Jev, and the Internet went wild. But why should we care? Is Jev really something entirely new?
Yes and no, as we'll see. In principle, Jev is a classifier, something that has existed in machine learning for decades (believe it or not, since 1957, in fact!). What makes Jev exciting is that it aims to give classification the semantic flexibility we're used to from LLMs, while retaining the principles we know from purpose-built classifiers in machine learning. And most importantly: they've made that functionality accessible so you can call it from code as if it was any other part of the code, because what you get back is predictable, unlike what you get from an LLM.
Still not much clearer? Classifier? Machine learning? Let's rewind a bit.
A tiny bit of AI history
Before generative models popularised artificial intelligence, making it generally accessible and made "AI" synonymous with "LLM" for most people, we had several decades of AI development in the form of machine learning: that is, training computers to recognise patterns and use them to make predictions.
Training an LLM is enormously expensive, but in the era of machine learning, models were mainly regression models and classifier models. These models were much simpler, and could be developed and trained on ordinary equipment available to most people. The challenge was that each model was specific to the task it was meant to solve. But what do they do?
Regression models try to predict continuous numbers based on learned patterns. Classifier models use the same principle, but instead of predicting numbers they try to predict a category or label.
Example: If you have two features (X and Y) and plot the data points on a chart:
A regression model tries to draw a line or curve as close as possible to all the points (which represent a continuous measurement) to capture the trend, so it can try to predict a continuous value for new data points.
A classifier model tries to find a decision boundary separating data points from different classes (two classes in this example, for instance Spam / Not spam) so it can predict which class a new data point most likely belongs to.
Source: the author, using AI.
Eventually, these models were replaced by foundation models: models capable of making such predictions for many different tasks, rather than just one specific task they had been trained to perform. The first and best-known examples of such foundation models are large language models (LLMs). The models are trained on enormous amounts of text data. For most people, Claude, GPT, DeepSeek, Gemini and so on are the best-known examples (although many of these today aren't just language models, but multimodal models that support computer vision, image generation and more).
So what is Jev, and why is it getting so much attention?
Jev is a classifier model. TypeSafe calls it a decision model, because that is Jev's main use case. Many people use small and fast LLMs for classification today, for example by asking "based on the contents of this email, is it a support request, a sales inquiry or a question about an invoice?" And language models are fairly good at this. But there are several problems with using an LLM for this, like:
they're slow
they're expensive
they get things wrong sometimes
they don't know when they're wrong...
Jev solves all four, at least to a degree. And Jev opens up something new and very exciting for using AI in applications: it lets us use AI as a new deterministic building block in code!
Deterministic AI model?
LLMs are generative and probabilistic. Jev is also probabilistic in its assessment of probability. After all, we're still talking about prediction. But Jev is deterministic in two specific and important ways:
1: no hallucinations: Unlike ordinary LLMs, Jev can't "make things up." If we ask Jev to classify an email into category A, B or C, there's no risk that Jev invents (hallucinates) option D. We get a response containing Jev's chosen category with a score showing how confident Jev is that it picked the right one. We also get a list of all the options it considered (which you supplied), with a probability score (confidence score) for each.
2: guaranteed schema: Ordinary LLMs produce text, and because that text is generated probabilistically, there's no guarantee you'll get exactly the format you want. It will often be right, but it's not unusual for the format they return to have one or more errors. When it's code that will use the answer from the model, such errors can't be tolerated. With Jev, this isn't a problem: it guarantees that the schema of the response you receive is correct every time, and therefore that the data is type-safe. That means you can query Jev from code and use its response directly in the code. This is big!
Note one important thing, however:
This doesn't mean Jev can't be wrong!
But where Claude, for example, gives you its answers with just as much conviction when it's wrong as when it's right, Jev will explicitly present how likely it thinks the chosen answer is. It is then up to you as the user to decide how confident Jev has to be before the system using it can make its decisions automatically, based on context and the consequences of a wrong assessment.
This opens up many new ways to use AI to assess questions that are difficult or impossible to specify precisely enough for traditional tests, because the system needs to "understand" an unpredictable and perhaps messy human/semantic context.
An example
Let's look at the example above where we want to classify an email. Instead of asking an LLM to make the assessment based on some guidelines it may or may not follow correctly, and which it may spend a long time thinking through before answering, with Jev we can split the problem into one or more questions:
Which category does the email belong to? (support, sales, financial, other) - Question type choice
Is it urgent to handle? (Yes/No) - Question type noul
Does the request need a human reply? (Yes/No) - Question type noul
What priority should the request get? (A calculated score) - Question type score
Jev assesses this enormously faster and more cheaply than the large language models. LLMs are general tools that can be used for just about anything, while Jev has a very narrow range of functions. To solve the task above, an LLM has to spend quite a lot of time reasoning its way to an answer by continually producing text/tokens, both as part of its reasoning and as the final answer. An answer that might be wrong.
Jev runs all the questions above in parallel, so it's about as fast with 100 questions as with just one. And each question is a very narrow task that's quick to perform.
Send the questions above to Jev, and you'll get a response with an answer to each question:
Category
"type": "choice"
"choice": "financial"
"confidence": 0.77
"probabilities":
"support": 0.16
"sales": 0
"financial": 0.83
"other": 0.01
Urgency
"type": "noul"
"noul": 0.96
Human reply
"type": "noul"
"noul": 0.91
Priority
"type": "score"
"score": 3.85
"confidence": 0.88
"legend":
"0": "No action required (spam, irrelevant etc)"
"1": "Low Priority"
"2": "Normal Priority"
"3": "High Priority"
"4": "Critical Priority"
"probabilities":
"0": 0,
"1": 0,
"2": 0.01,
"3": 0.13,
"4": 0.86 (Actual response is json)
So what's deterministic is the format of the answers you get, and what the possible answers are for each question. This means we can define in code what to do with the answers we get, based on business rules we set.
Jev doesn't make decisions for us, but gives us a predictable ground for decisions we need to make.
For example, we could say the confidence score for "human reply" must be over 0.85 for the request to be forwarded to a person to answer. Or that "human reply" must be over 0.85 and "priority" must be "critical" with a confidence of 0.8 or higher, and so on.
This gives us a completely different kind of flexibility than an LLM, it gives us an answer enormously faster and, not least, at a vanishingly low cost compared to using an advanced LLM.
But how stable are the assessments?
When we talk about determinism in computer systems, we usually mean: given the same input values, a function will always produce the same output. That's not the kind of determinism we're talking about with Jev, as explained above. But if the answer isn't guaranteed to be identical, how much variation can we expect?
I couldn't find a good answer to that, so I wrote a small program to test it. The goal was to run the same query against Jev 100 times in a row to see how much its assessments varied. My query asked the same question ("does this function satisfy a given requirement regardless of what values I pass in?") in three different ways: as a choice question, a noul question and a score question:
choice:
"criteria": {
"satisfies": "The implementation satisfies every part of the requirement.",
"violates": "At least one possible input violates the requirement.",
"insufficient_evidence": "The supplied implementation or requirement is incomplete, preventing a conclusion."
}
Result: 100/100 "satisfies"
noul:
"Does `implementation` satisfy `requirement` for all int arguments?",
Result:
0.96 (72/100)
0.97 (28/100)
score:
criteria: [
"clearly violates",
"probably violates",
"ambiguous",
"probably satisfies",
"clearly satisfies"
]
(The API converts these to 0, 1, 2, 3, 4 based on position)
Score: all 100 returned 3.99/4 To summarise, the questions I used resulted in
100% "satisfies"
Only 2 different noul values, with around 3/4 of responses giving a probability score of 0.96 and the rest 0.97 (anything above 0.5 is yes, below is no)
A score of 3.99 out of 4 for all 100.
That's very stable, and bodes well for use in production!
Half of the 100 queries took 344 milliseconds or less (median), and only 5% took more than half a second (p95).
The entire test produced 8,100 output tokens (which are free) and 58,600 input tokens (which cost $0.042 per 1 million). The price of running the test is therefore 58,600 * ($0.042 / 1,000,000) = $0.0024612.Yes, that's cheaper than LLMs...
OK, but what can Jev be used for?
How useful is this really? What can it be used for, beyond the boring example of classifying emails? For me personally, there are 2 things I'm going to experiment with using Jev for first:
Evals
Jev is a perfect fit for building evaluation layers during development to catch small deviations from the intent while it's still cheap to do something about them (as I wrote in my first article on AI adoption). And also for catching drift (model drift/deviation from intent) in established AI-supported systems when models change, input data changes and so on (as I wrote in my second article on AI adoption).
Model routing
I've written about this before too. Sending every request to the same model, regardless of the type of task, isn't very efficient. Before Jev, I didn't have a clear answer to how I could build such a router in a predictable way. Jev can make many parallel assessments of a prompt and classify it according to whatever logic I choose to use to decide which model should be used for each type of task, without noticeable delay.
Other examples
Although the two above are the ones I personally want to try first, there are plenty of other uses you can imagine Jev simplifying, for example:
Risk/guardrails: for example, classify an action as low/medium/high risk before an agent is allowed to perform it.
Content moderation: for example, spam, abuse, sensitive information, personal data, etc.
Prioritisation/triage: for example, email, support request, alert -> urgent/not urgent, category, priority.
Semantic filtering during data retrieval: for example, "Is this document relevant to the task?" before the document is brought into the context window.
Information extraction: for example, convert unstructured text into predefined values.
Quality assessment: for example, "Is the generated answer good enough to send to the customer?" Or assess several predefined characteristics.
Anomaly detection: for example, "Does the event/log/action look suspicious, given the context?"
RAG: for example, "Do I have enough information to answer?", "Should I look for more information?", "Which source category should I search in?"
Program flow: Replace complicated conditionals like if keyword X && customer_type Y && expirationDate > Z … with a semantic decision.
Summary
I think the launch of Jev represents a substantial change in how we'll use AI in the future. It isn't a direct competitor to the large LLMs, because it solves a different problem. But Jev, and surely many similar models that will appear soon from the major providers, or from the open weights models community, can replace LLMs in some of today's use cases.
And most interesting of all: Jev makes it possible to use AI for things we haven't had a good solution for until now
It'll be exciting to see how Jev influences the AI field from here! In the meantime, I recommend taking a look at awesome-jev-use-cases for both useful and especially less useful ways to use Jev!
And, if you were wondering: of course Jev plays Doom...
This is a translation of a Norwegian article I initially published on LinkedIn, September 22 2026.