Unpacking the success of Jev and AI decision models

TypeSafe AI just raised $870 million at a $7.5 billion valuation, less than a month after releasing its first AI model Jev, which makes structured decisions instead of generating text.

At first glance, the concept seems too simple to justify such excitement. Machine learning models have been classifying data and making predictions for decades. So why did Jev suddenly become one of the hottest AI technologies?

The answer has less to do with a breakthrough in classification and more with the convergence of several trends. The evolution of AI applications, the growing cost of agentic workflows, and advances in foundation models created the perfect storm for a new generation of decision models.

Just another classifier?

Jev belongs to a new category of models that TypeSafe calls “System One Models,” aka “decision models.” It takes unstructured information, such as text or application state, and produces structured outputs that software can act on directly.

For example, a customer-support application can provide Jev with an email and ask it to determine the customer’s intent, the urgency of the request, and which department should handle it. Jev returns predefined choices and probabilities without generating a textual response.

But classification is nothing new. Traditional algorithms such as logistic regression, decision trees, and XGBoost have been used for decades. Deep learning extended these capabilities to unstructured data. For example, developers could fine-tune BERT with a classification head to categorize raw text. 

These approaches have their tradeoffs. Traditional classifiers often need labeled examples, training, and maintenance. But given the pace at which AI has advanced in the past few years, these approaches often have prohibitive requirements that slow down the development process.

Jev and other decision models address a newly emerged gap that has not been filled.

Why AI suddenly needs decision models

Two years ago, a model like Jev might not have attracted a fraction of today’s attention. But AI applications have changed considerably.

Since the release of ChatGPT, developers have moved from simple chatbots and content-generation tools to agents that interact with software, execute workflows, and complete complex tasks.

Consider a coding agent that must implement a feature in an existing repository. It needs to inspect the codebase, select relevant files, generate code, run tests, evaluate the results, and decide whether to retry or finish.

Some of these operations require generating code or text. Many others require decisions: Which tool should the agent call? Did the test pass? Is the proposed change safe? Which of several candidate solutions is better?

Developers have several ways to handle these decisions. Simple conditions can be expressed through deterministic code and heuristics. Tasks with structured inputs and stable requirements can often be handled by traditional machine-learning models.

The challenge arises when decisions involve unstructured information and changing criteria. Building and maintaining a specialized classifier for every new task becomes impractical, especially in agents that must handle diverse situations.

LLMs have helped fill this gap. Through prompting and in-context learning, developers can turn a general-purpose model into a classifier or an LLM-as-a-judge that evaluates responses, code, and agent actions.

But this approach has its own limitations.

First, LLMs are designed to generate sequences of tokens. Even if an application only needs a yes-or-no answer or a choice between several tools, a generative model must still produce an output token by token. Reasoning models can introduce additional computation before producing the answer.

The overhead becomes important when decisions are repeated throughout a workflow. For example, adding just 100 milliseconds to each of 20 sequential decisions increases the total execution time by two seconds.

Second, developers must ensure that LLM outputs can be interpreted by their software. Modern APIs support constrained decoding and structured outputs, which can solve many formatting problems. But they still rely on general-purpose generative models for tasks that only require bounded judgments.

This is the gap that Jev addresses, combining the flexibility of LLMs with the efficiency and accuracy of specialized classifiers. Developers define the decision questions and possible answers at inference time. Jev processes the supplied context and returns structured values and probabilities without autoregressive text generation.

In its published evaluations, TypeSafe reports that Jev can be up to 193.6 times faster and 444.6 times cheaper than LLM-based alternatives on selected workflows.