JEV: an AI Model that's built for Machines

04 Nov 2026 06:32 PM - By Yogesh Verma

For the last few years, much of the AI revolution has revolved around Large Language Models (LLMs). We've become accustomed to asking AI questions, having conversations, generating code, summarising documents and even reasoning through complex problems.

But there's an interesting gap in this picture.

What happens when AI is not interacting with a human? What if its job is simply to make a decision that another piece of software can act upon?

Think about the countless small decisions happening inside an application: Is this request a billing issue or a technical issue? Should this transaction be flagged? Which workflow should handle this task? Is this action safe enough for an autonomous agent to execute?

There are some problems that not necessarily need a paragraph of generated text. They need a fast, reliable and structured decision. This is where Jev comes in.

What exactly is Jev?

Jev is an AI model developed by TypeSafe AI, designed specifically for making fast, structured decisions that software can consume directly.

Jev is an AI model built to make fast, structured decisions that software can use directly.

Unlike conventional LLMs, Jev doesn't generate text. It uses a non-autoregressive architecture to produce probability-based predictions over predefined, structured answer schemas. In simpler terms, you provide Jev with some context and ask it specific questions. It evaluates the questions and returns structured answers, along with probabilities indicating how likely each answer is to be correct.

Why do we need a model built for machines?

Most modern LLMs are designed around human interaction. They receive a prompt, process the context and generate a response, one token at a time. This is called autoregressive generation: each generated token depends on the preceding tokens.

It's a remarkably powerful approach. But it comes with an inherent overhead when the objective is simply to make a decision. Imagine asking an LLM whether an incoming support request belongs to the Billing, Technical or Sales team.

The model might generate: "This appears to be a billing-related query because the customer is reporting a discrepancy in their invoice. Therefore, the appropriate department would be Billing."

Your application then needs to interpret the response, extract the answer, validate it and decide what to do next. But what if all you needed was: Billing: 0.94. The rest of the generated explanation wasn't necessary for the application to make its decision.

This is an important distinction. LLMs are excellent at producing information for humans. But software often needs decisions. Jev is designed to provide machine-consumable intelligence without the overhead of generating language.

System 1 and System 2: Where does the name come from?

Jev belongs to a category TypeSafe calls System One Models.

The terminology draws inspiration from Daniel Kahneman's bookThinking, Fast and Slow, which describes two modes of human thinking.

  • System 1:Fast, intuitive and largely automatic thinking. For example, recognising a familiar face or quickly identifying a spam email.
  • System 2:Slower, deliberate and analytical thinking. For example, solving a complex mathematical problem or evaluating a business strategy.

The idea behind System One Models is to make fast, focused decisions rather than generate elaborate reasoning or explanations.

Interestingly, the name Jev has its own story. It is inspired by William Stanley Jevons, the economist known for the Jevons Paradox. The paradox describes how improvements in efficiency can lead to increased consumption rather than reduced consumption. TypeSafe draws a parallel with machine intelligence: as the cost of intelligence drops, entirely new use cases become economically viable. In other words, making AI dramatically cheaper could actually increase how much AI we use.

Jev vs. LLMs: A fundamentally different approach

The two are designed around different objectives. Here are the key differences:

  • Primary purpose:LLMs are designed to generate language, whereas Jev is designed to make structured decisions.
  • Output:LLMs produce text or generated tokens. Jev returns typed answers along with probabilities.
  • Generation:LLMs use autoregressive generation, producing tokens sequentially. Jev uses a non-autoregressive approach.
  • Processing:LLMs generate responses token by token. Jev evaluates decisions in parallel.
  • Uncertainty:LLMs can provide confidence estimates, but these aren't necessarily calibrated. Jev is designed around calibrated probabilities.
  • Best suited for:LLMs excel at conversations, reasoning, writing and coding. Jev is better suited for classification, scoring, routing and structured decision-making.

The architectural difference is particularly interesting. An LLM generates its response sequentially. Jev uses a parallel sampling approach to evaluate the requested decisions without having to generate a sequence of words. This makes it significantly more efficient for tasks that have a defined answer space. And because Jev's output structure is defined in advance, the application doesn't have to worry about unexpected response formats or malformed outputs.

How does Jev actually make decisions?

At a high level, Jev works with three fundamental question types:

1. Choice: Choose one answer from a predefined set of options. For example, given a customer support ticket, classify it as Billing, Technical, Sales or Other. Jev returns the selected option along with probabilities for the available choices.

2. Score: Evaluate something against a defined scale or rubric. For example, assess the severity of an incident on a scale of 1 to 5, or score customer satisfaction across defined levels.

3. Noul: A yes-or-no question that evaluates whether a particular statement is true. For example: Is this transaction suspicious? Does this request require human approval? Is this action potentially unsafe?


The interesting part is that you can ask multiple independent questions about the same context in a single request. Jev evaluates them in parallel. This opens up possibilities beyond simple classification. You can build a series of intelligent decision points within an application without repeatedly invoking a large generative model.

And how is it trained?

Traditional LLMs are largely trained to predict the next token, followed by post-training techniques such as Reinforcement Learning from Human Feedback (RLHF), which help align their responses with human preferences.

TypeSafe takes a different approach with Jev. Its post-training method is called Reinforcement Learning for Calibrated Decisions (RLCD). The objective is not merely to produce an answer that looks convincing or is preferred by a human evaluator. It is to produce probabilities that meaningfully reflect the likelihood of an answer being correct.

Does Jev eliminate hallucinations?

This is perhaps one of the most interesting claims associated with Jev.

LLMs are more prone to hallucinate because they generate open-ended sequences of text. They can produce information that sounds convincing but is factually incorrect, or even return outputs that don't conform to the structure expected by an application.

Jev takes away much of that freedom. If you ask it to choose between four predefined categories, it cannot invent a fifth category. If you ask it a yes-or-no question, it cannot return an unexpected paragraph instead. This makes hallucinations and type errors structurally different problems. However, Jev can still make an incorrect decision.

What it eliminates by design is the possibility of generating arbitrary, out-of-schema answers. It does not guarantee factual correctness. That's why calibrated probabilities matter. They allow the application to establish confidence thresholds and decide when to proceed, retry or involve a human.

Why is it a good idea to use Jev instead of LLMs for decisions?

Because most automation does not need words. It needs a decision. Jev closes several gaps that appear whenever we use LLMs as decision engines:

  • Latency.Agents and real-time systems cannot wait seconds per step. Jev answers in milliseconds.
  • Cost.TypeSafe claims Jev is 20 to 200 times faster and 40 to 400 times cheaper than LLMs on decision-shaped tasks.
  • Reliability.No parsing, no retries for broken JSON, no invented categories.
  • Confidence.LLMs sound equally sure when right and wrong. Jev's calibrated scores let code decide when to trust it and when to escalate.
  • Control.Business rules live in your code as thresholds and weights, not buried in a prompt.

Where does Jev shine?

Think about the number of small decisions that an application makes every day. Many of these decisions are too nuanced for conventional if-else statements but don't need a full-fledged LLM either. Some interesting use cases include:

  • Intelligent ticket routing:Understand an incoming request and route it to the appropriate team.
  • Fraud and risk detection:Evaluate transactions and flag suspicious patterns for further investigation.
  • Agent orchestration:Decide which tool an AI agent should invoke, whether it needs human approval, or which workflow should execute next.
  • Content moderation:Classify content against predefined policies and determine whether it requires review.
  • Application security:Evaluate whether an action or tool invocation is potentially unsafe.
  • Data classification:Categorise large volumes of unstructured information into meaningful business categories.

Consider an autonomous agent processing an expense reimbursement request. It might need to answer several questions:

  • Is the submitted document an invoice or a receipt?
  • Does the expense fall within the company's policy?
  • Is the amount unusual?
  • Does this request require managerial approval?

These decisions can be evaluated independently and in parallel. The application can then combine the results with its existing business rules to determine the next step. That's where Jev's speed and efficiency become particularly valuable.

Will Jev replace LLMs?

No. LLMs and Jev solve different problems. An LLM is useful when you need to understand complex instructions, reason through an unfamiliar problem, generate content, write code or communicate with a human. Jev is useful when you need a fast, structured decision within a software workflow.

In fact, the two can complement each other rather well.

Imagine an AI agent powered by an LLM. The LLM handles the complex reasoning and interaction, while Jev handles frequent, well-defined decisions such as classifying inputs, evaluating risk, selecting workflows and checking whether an action should be escalated.

The LLM provides the broader intelligence; Jev provides a specialised decision layer. Of course, the actual division of responsibility depends on the application and how well each model performs on the relevant tasks.

A different direction for AI

The AI industry has largely been focused on making models better at generating language. And understandably so. Language has been the most accessible interface between humans and machines.

But as we move towards autonomous agents and increasingly intelligent software, the requirements are changing. Software doesn't always need another paragraph. Sometimes it simply needs to know what to do next.

That's what makes Jev interesting.

Yogesh Verma

Yogesh Verma

Share -