Jev: an AI model for making decisions in our applications

Over the past few days, I have seen Jev, a new AI model, everywhere in my X (Twitter) feed.

Another new AI model? Yes, but this one is not trying to write better articles, code an application, or replace ChatGPT.

Jev, TypeSafe's new model, does not generate text. It answers questions for which we define the possible responses.

Classifying a customer message, detecting an urgent request, or choosing the next tool to call: our applications and AI agents make many small decisions. We often use an LLM for this work, adding latency and cost to every call, even when all we need is a yes or no answer or a category selected from a predefined list.

Jev is designed for this job. It receives context and questions, then returns choices, scores, and probabilities that the application can use directly. Because its responses are limited to the allowed options, TypeSafe presents it as a model with “no hallucinations.”

TypeSafe reports response times of 70 to 500 milliseconds, up to around 200 times faster and 400 times cheaper than the LLMs compared in its evaluations. The price is $0.042 per million input tokens, with no charge for output tokens. This is the promise behind its first “System One” model, introduced on September 15, 2026.

I recently gained access to the service and am considering the best ways to use it in my projects. Here is how it works and what I plan to explore.

What Jev actually does

To use Jev, we provide two elements:

• A state: the data to analyze. This can be a single message or a collection of information.
• questions: what we want to know about that state, with the possible responses defined in advance.

Jev supports three types of questions:

The difference between Score and Noul matters. The first indicates a degree, such as the severity of a problem. The second indicates the probability that a statement is true: a value of 0.5 means that the model is uncertain between yes and no.

Choice and Score responses also include a confidence indicator, summarizing whether the probabilities are concentrated on one response or spread across several possibilities.

Multiple questions can be evaluated in parallel within a single request. They share the same context, but each one is evaluated independently. The same context can therefore support several decisions in one call, without sending it repeatedly or waiting for answers one after another. The application can then combine the results to decide what happens next.

An example: routing a support message

Imagine that a user sends the following message. It becomes our state:

{
  "message": "My reports have not opened since this morning. I have a client presentation in two hours. Can you help me?"
}

I want to obtain three pieces of information:

• Topic (Choice): bug, billing, feature request, or other.
• Reported impact (Score): 0 for a minor inconvenience, 1 for a degraded feature, and 2 for a blocked task.
• Urgent deadline (Noul): does the message mention a near-term deadline that requires attention?

Here is a simplified excerpt of what Jev could return. The values are fictional and only illustrate how it works.

{
  "answers": {
    "topic": {
      "choice": "bug",
      "probabilities": {
        "bug": 0.92,
        "billing": 0.02,
        "feature_request": 0.04,
        "other": 0.02
      }
    },
    "impact": {
      "score": 1.85,
      "probabilities": {
        "0": 0,
        "1": 0.15,
        "2": 0.85
      }
    },
    "urgent_deadline": {
      "noul": 0.98
    }
  }
}

The application immediately has the useful information: a probable bug, an impact close to “blocked task,” and an urgent deadline.

It can route the message to technical support and move it up the list of requests that need attention. If a customer response needs to be written, a generative model can take over.

Jev interprets the message, the application organizes its processing, and a generative model writes when necessary. Jev can therefore be integrated into an existing application, with or without an agent.

The Jev Playground lets you test a state and its questions before integrating them into an application.

A new “System One” model

The System One name refers to the distinction popularized by Daniel Kahneman between fast, intuitive thinking and slower, deliberate reasoning.

TypeSafe applies this idea to focused judgments. Recognizing a refund request is not the same job as building a technical migration plan.

The company describes an architecture that evaluates outputs in parallel and a training method called RLCD, or Reinforcement Learning for Calibrated Decisions. One objective is to produce probabilities that better reflect the model's uncertainty, as explained in the System One documentation.

LLMs can already classify text and return structured data. The novelty is therefore not the ability to obtain JSON. It lies in a model specialized for this task that gives up open-ended generation.

This specialization opens up use cases where speed and volume matter: classifying a large number of comments, routing a request during a user journey, or choosing among the tools available to an agent.

Jev's other advantage is its price: only $0.042 per million input tokens, with no charge for output tokens. To give a concrete example, analyzing 100,000 messages of 1,000 tokens each, including the questions, would cost $4.20 in Jev calls. That price makes it possible to consider using the model across large volumes of data.

Speed, volume, and cost: the three arguments that make Jev interesting for repeated decisions.

Three ideas I am considering for my projects

Several tasks in my projects already rely on understanding language in this way: identifying what a customer is expressing, recognizing useful information, or determining the topic of a request. These are the first ideas I want to explore with Jev.

1. Sorting customer reviews in Begonia

In a local SEO product such as Begonia.pro, customer reviews provide useful material for this type of model to analyze and classify.

I could test Jev with questions such as:

• Does the review mention the welcome, waiting time, price, or quality of service?
• Does it describe both a positive experience and a problem in the same message?
• Does it report a situation that the business should review as a priority?

The objective would be to help the business identify recurring topics. The code would remain responsible for counting them, while a generative model would draft responses, subject to approval before publication.

2. Qualifying information collected for prospecting

I previously tested a local model (Google's Gemma) in a prospecting prototype to reduce costs.

Jev could step in after data collection to assess specific criteria: does the company offer a software product? Does it describe a use case for professionals? Does it mention integrations with other tools?

These signals could feed filters in my tool and help me select the companies worth reviewing.

Its speed would let me qualify the information much faster than with the local model, while keeping costs under control.

3. Choosing the right tool in my Shopify prototype

In my agentic commerce prototype with Claude and Shopify, Claude selects which tools to call to search for products, retrieve store information, or manage the cart.

Jev could handle some of these decisions: which tool should be called now? Selecting the next tool is one of the use cases presented for Jev.

I would provide the conversation context and a list of available tools with their descriptions. A Choice question would let it select the appropriate tool:

• “I am looking for a moisturizing facial treatment” → search the catalog.
• “Do you deliver to Belgium?” → check the shipping policy.
• “What have I already added?” → read the current cart.

The choice would be limited to tools that are actually available in the application. I would also include an option to hand control back to Claude when the request requires clarification or more advanced reasoning.

The application would then prepare the required arguments when they are already available or can be derived from the context. A generative model could still step in for requests that require more open-ended interpretation. The application would execute the selected tool with its usual safeguards, then Claude could use the result to compare products, advise the customer, or write a response.

The goal would be to reserve generative model calls for the steps that genuinely require them, while using Jev for simple, frequent tool-selection decisions.

Limitations to keep in mind

Jev specializes in focused decisions. It does not replace a generative model for writing a response, explaining a choice, or carrying out complex reasoning. It currently accepts text, but not images, audio, or video directly. TypeSafe's documentation also states that it performs better in English than in other languages.

The “no hallucinations” promise also needs clarification: Jev cannot invent an answer outside the options provided, but it can select the wrong one. The quality of the questions, categories, and context therefore remains essential. Providing an “other” option or human review helps handle ambiguous situations.

Finally, the reported speed and cost improvements come from TypeSafe's evaluations. They depend on the tasks and models being compared and will not necessarily appear in the same proportions in every application.

The proposition is nevertheless compelling: a generative model for writing and reasoning, Jev for focused decisions, and code to organize the whole system. Each component can be used where it brings the most value.

What small, repetitive decision in your application would you like to delegate without handing the entire workflow over to an agent?

📌 Do you want to integrate AI into a product or automate a business process? I can support you from initial scoping through the first experiments with my Product Engineering services.

Further reading

• TypeSafe, Introducing System One Models and Jev.
• TypeSafe, documentation and quickstart.
• Sydney Runkle, “Building a Harness with Jev”.
• Flavio Copes, a detailed introduction to Jev.
• Rory Garton-Smith, EasyJev interactive demos.