Jev in a Nutshell & 5 Ways You Could Be Using It Right Now

Reliability and efficiency are software engineering’s bread and butter—Can Jev solve this for AI engineering?

I’ve finally gotten around to looking at TypeSafe AI’s new “System One Model” called Jev that made waves this last week. There’s a lot to be excited about here. This model has the potential to not only improve what can be done with LLMs but also extend what’s possible when building software.

I haven’t gotten the chance to try Jev myself, and I usually wait to comment on new AI models until I can try them, but Jev is a model that has me excited about the future possibilities of what these models can do.

In this article, we cover:

1. The background you need to know

2. What Jev is

3. What you could be doing with it right now

4. Its impact on engineering

---

Exciting news! I’ve partnered with Into AI by Dr. Ashish Bamania to bring a 90-day free trial and 40% off the ‘LLMs in 100 Images’ book to all AI for Software Engineers paid subscribers. Check these out on our perks page!

I’m a big fan of Into AI and Dr. Bamania’s breakdowns, so I’m really excited to bring this to you. I think it’s a big step in making the best AI learning materials more accessible to you.

Thanks to all paid subscribers of AI for Software Engineers! You can support the newsletter and get access to more great AI resources and exclusive perks for just $5/mo.

---

The background you need to understand Jev’s impact

There are a few fundamental AI and machine learning concepts to understand before getting into Jev. Some of these are very basic, so feel free to skip this section if needed.

First, the real gain of LLMs comes from their general intelligence. A single LLM can perform many tasks without retraining or requiring additional data collection. This increases development velocity so much that it’s driven the rise of AI engineering and the new wave of generative AI on its own.

Second, traditional classification models don’t have this same benefit. While traditional classification models are very performant, adding new functionality (such as classifying a new class) requires collecting data and retraining the model. Data collection and retraining are incredibly time-intensive parts of machine learning.

Third, LLMs can be used to perform classification tasks simply by providing the model with what needs classifying and the criteria for classifying it. The accuracy and reliability of this classification depend on the intelligence of the LLM. There’s always a possibility the non-deterministic nature of the LLM will cause a misclassification.

Last, LLMs tend to be significantly more expensive than traditional classification models. Running an LLM requires passing input through all its parameters, which is expensive both in terms of cost and latency. Traditional classification models tend to be both cheaper and faster.

Even with the added cost, latency, and potential reliability hit, using an LLM for classification can be worth it simply due to the development velocity increase. Jev aims to solve the cons of using LLMs for classification while maintaining the pros.

Jev in a nutshell

“Think of Jev as a frontier-intelligence function call: unstructured state in, typed probabilistic decisions out.” — Diogo Almeida, TypeSafe AI’s Introducing System One Models & Jev

I think it’s helpful to think about Jev as bridging the two different types of models: It brings the efficiency and reliability of classification models to LLM applications while maintaining the general intelligence and task flexibility of LLMs during classification tasks.

Jev is used to classify and score text using instructions a user provides. The user provides state (the input the model needs to be aware of), a type of classification (see below), and scoring criteria. Jev returns a structured decision and probabilities of classification instead of generated text like an autoregressive LLM.

Original LangChain illustration illustrating Jev’s different classification options.

For the type of classification, a user has three options (see the image above):

1. Choice: Give Jev a set of classes that it can choose from. Jev will provide a probability score for each class and a confidence score for its own results for each item scored.

2. Score: Tell Jev to score something on a scale. Given an item and scoring criteria (generally a rubric), Jev will provide a score for the item and a confidence score for its own output.

3. Noul: Tell Jev to answer yes or no based on a given question, and Jev will output the probability of a yes.

TypeSafe reports Jev to be 193.6x faster and 444.6x lower cost on its evaluations compared to performing the same tasks with autoregressive LLMs, though TypeSafe expects these figures to be on the higher end of real-world gains. In TypeSafe’s 13-question example in the documentation, one combined request costs 12x less than separate requests for the same input.

LangChain tested reliability by having Jev, GPT-5.6 Luna, GPT-5.6 Terra, and Claude Sonnet 4.6 judge the same five saved weather-agent responses 100 times each. Jev’s quality scores had 92–913x lower variance, meaning its scores changed far less when judging the same output repeatedly. In this small test, it also matched a human reviewer’s pass/fail labels on all 500 repeated judgments, compared with 80–99.8% for the LLM judges.

Fundamentally, this means classification tasks that would previously be delegated to autoregressive LLMs can instead use Jev at a fraction of the latency and price with greater consistency.

Some examples of what Jev is useful for right now

1. Model routing

This is the application I first thought of and was most excited about when reading about Jev.

One of the biggest agentic development velocity gains right now is understanding the tasks you can and cannot use Flash-tier models for. Being able to ask an agent a question or to do a simple task and get a result without having to switch work context is a huge development velocity gain. Increases in the speed and capabilities of recent Flash-tier models have made this possible.

Jev can be used on the first turn of a conversation to assess a user query and decide whether a Flash or Pro model should be used to complete the task. Currently, this can be done via a separate agent and other heuristics (including heuristics that benefit the serving provider rather than the user), but getting this wrong can be incredibly detrimental to the user experience.

I find most of my agent use is classified into one of two buckets:

1. What is the answer to this simple thing?

2. A rambling message explaining what I need the agent to do, what I’m looking for from the agent, and anything I might need built.

Using Jev’s Choice option would be perfect to decide what type of model fits each.

2. LLM-as-a-judge

The difficulty behind using LLMs in real-world systems, and the entire impetus for AI engineering as a field, is the non-deterministic nature of LLMs. In traditional software engineering, systems are built to ensure determinism and make systems easily testable. LLMs force a different approach to assessing system functions.

LangChain’s cost comparison when testing Jev-as-a-judge against other models. They found it to be faster, cheaper, and more consistent in its analysis.

Evaluations (evals) are used to measure system function. One approach, LLM-as-a-judge, uses a separate LLM to judge the output of the system being evaluated, scoring it against its expected performance. Jev’s Score function is perfect for this.

LangChain tested this themselves and found Jev to cost less, answer faster, and be more precise.

3. Assessing hallucinations

One of the most difficult things about using an LLM as a research or learning tool is assessing whether what it’s telling you is hallucinated or truthful. The result is having to read through the output and check the source material yourself.

I’ve used many strategies to try to make agent output more reliable: asking another agent to assess the truthfulness of the stated information, forcing the agent to pull and share direct quotes from the source material that prove any claims made (and then using an agent to assess whether that quote itself is hallucinated), and many more. I’ve found all of these subagent-based approaches to be at least somewhat unreliable and expensive.

If Jev can reliably determine whether information is present within a given input, it can automate much of the information gathering I currently do that needs to be reliable.

On a broader scale, more reliable detection of unsupported claims in learning material could open up many applications for AI in education.

4. Involving the user

With the increasing intelligence of LLMs and improvements in agent harnesses, agents are being increasingly applied to long-horizon tasks where the agent needs to ingest context and reason over long periods of time.

In my experience, the context engineering required for these tasks can be tricky. You don’t want to overcrowd your context window, but a long-running task that doesn’t have enough context will continue running without any hope of successful completion. This can be incredibly costly.

Jev can be used to help the model assess whether it has the information needed to complete a task or whether it needs to involve the user to do so. While this can be done with separate agents, it’s expensive to use another agent to frequently assess the actions of an agent running for days on end. An agent recognizing a lack of context early can save a lot of time and money.

5. Filtering

One of the most common, simple applications I see LLMs used for is filtering a set of items based on given criteria. I use this each day by having an agent go through my admittedly overpopulated RSS feed and filter it down to just what I would find interesting.

This also applies to any sort of yes-or-no question about a given context, assessing sources for validity and/or credibility, checking content for specific topics or formats, and much more.

With Jev, this can be simply applied by giving it an item and assessment criteria and using Jev’s Noul functionality to determine if it’s a keeper or not.

The Future Impact on Engineering

All of the above applications are exciting, but there’s an even larger implication for generalized intelligence that can reliably produce the desired output. The real crux of engineering isn’t just building software—it’s building software that works reliably and consistently, and scales well. A current blocker in AI systems is that it takes an incredible amount of engineering to make these three things somewhat true.

Somewhat is the important distinction in that statement. We don’t have 100% reliable generalized AI automation. In many cases, we have good enough automation via LLMs, and that makes for great AI systems. Other cases still require a human in the loop. Jev is the next step toward true generalized intelligent automation.

The existence of generalized intelligent automation expands the possibilities of what we can do with technology. Alongside the explicit rules and if statements we use now to create reliable routing and decision-making within our programs, we can create much more intelligent and consistent systems with models like Jev.

A presentation by Diogo Almeida at AI Engineer explores this in more detail, and I highly recommend watching it:

---

There are many more applications of Jev that will emerge as it’s used more. I’m especially excited to see how other labs start developing similar models and integrating them into their products.

I’m also very excited about the implications Jev carries for agent systems and AI engineering in general. More reliable software is better for everyone.

Thanks for reading!

Always be (machine) learning,

Logan

If you’re interested in understanding more, check out these resources.

• Introducing System One Models & Jev by TypeSafe AI

• System One by TypeSafe AI

• Building a Harness with Jev by LangChain

• Jev-as-a-Judge for Agent Evals by LangChain

• Parallel questions by TypeSafe AI

• Re-ranking by TypeSafe AI

• API reference by TypeSafe AI