---
title: "What is Jev? TypeSafe AI's System One model"
description: "Jev is a new AI model built for decisions, not chat. Here's what it is, how it scores confidence, and where it fits in your workflows."
image: "https://images.ctfassets.net/lzny33ho1g45/79c0jaoNKHOrub8Aqc8e3d/93fb8eacbf83916bac67528941d91140/typesafe_ai.jpg"
---

# What is Jev? TypeSafe AI's System One model

Jev is a new AI model built for decisions, not chat. Here's what it is, how it scores confidence, and where it fits in your workflows.

When you ask an LLM to give you a confidence score for any decision it makes, you get vibes. I've built tools where the model said it had 95% confidence in a response, and then promptly changed its tune when I asked again 30 seconds later. This makes it hard to control hallucinations or imprecision, and it's a big barrier to fully automating segments of workflows, such as a complex customer support routing system.

And then Jev hit the scene. It's a decision-making [AI model](https://zapier.com/blog/types-of-ai-models/) that's not an LLM, can't chat, and can't hallucinate. It finally gives a clean confidence score that you can work with—among other useful data points.

**Table of contents:**

- [What is Jev?](#what)
- [How does Jev work?](#how)
- [What can you use Jev for?](#use-case)
- [Jev vs. LLMs](#vs)
- [Jev limitations](#limitations)
- [How to get started with Jev](#start)
- [Jev FAQ](#faq)

## What is Jev?

Jev is a new AI model from TypeSafe AI that makes decisions. When you provide questions and a state (the context you want to question), it returns a typed answer with a confidence level; you can use this output to decide what happens next in a system or workflow. Unlike [LLMs](https://zapier.com/blog/best-llm/), it doesn't generate text or images. Instead, it's a fast and low-cost component to build routing tools, classification steps, or safety filters. It's even been called a "[smart if statement](https://flaviocopes.com/jev/)."

It's perfect for decisions you have to make a thousand times a week: things like sorting documents, tagging tickets, or picking the best model for the job. And because it's fast and cheap, it doesn't kill your budget.

Jev launched in September 2026 after two years in development. The company frames it as a [System One](https://typesafe.ai/blog/introducing-system-one-models-and-jev) model, meaning it's fast and instinctive, compared to System Two models that take a slow and deliberate approach. These are concepts borrowed from Daniel Kahneman's _Thinking Fast and Slow_ book.

The model itself is named after William Jevons, who, in 1865, coined the Jevons Paradox: when a technology makes something cheaper and faster to do, people tend to do more of it, with consumption soaring as a result. In this line of thinking, if making decisions becomes more efficient over time, systems will make more decisions, improving outcomes at scale.

Now, Jev is publicly available through its [API](https://docs.typesafe.ai/api).

## How does Jev work?

Jev works using three main question types:

- **Noul. **This is TypeSafe's word for a yes/no question; it's scored on a 0 to 1 scale (1 being closer to yes).
- **Score. **This, predictably, scores something against a rubric (it also gives you probabilities and confidence level).
- **Choice. **Here, Jev picks one option from a set of options you provide (it also gives you probabilities and confidence level).

You'll choose which question type to use, and you can use more than one question (and question type) in a given request. You'll also input the state, which is whatever you're asking the questions about.

### Jev AI example

Let's walk through TypeSafe AI's CV screening example. The objective: understand if a candidate is a good match for our company by evaluating it against a set of criteria. Here are the three fields present in this scenario, showing the types of questions Jev can handle:

- `llm_experience` (Noul) determines whether a candidate has experience developing LLMs. There are two simple prompts attached to yes and no to help the model understand what each option looks like.
- `technical_depth` (score) tells Jev to rate the hands-on engineering capabilities of the candidate based on six pre-determined options. Each option is numbered, from 0 (candidate has little depth) to 5 (has owned and maintained entire systems).
- `career_progression` (choice) attempts to understand the candidate's career strategy. Jev has four options to pick from to judge whether they've been job-hopping or kept a steady growth trajectory.

With the questions in place, you can now pass a state: in this case, a CV of one or multiple candidates. Here's what the example CV input data looks like.

I ran this CV through Jev.

For the `llm_experience` question (type: Noul), it ranked whether the candidate had experience with LLMs on a 0 to 1 scale, with yes being closer to 1. It gave me 0.04 for this candidate, meaning they're not familiar with this type of technology.

On `technical_depth` (type: score), the story is different: the candidate was ranked 4, which shows hands-on engineering skills. Notice the legend: this was provided in the input prompt as the criteria Jev evaluates the CV against.

As for `career_progression` (type: choice), it ranked each choice out of a total of 1:

- 0.83 for steady growth
- 0.16 for job-hopping
- 0.01 for lateral moves

Each answer comes with a confidence score. For example, Jev was completely confident in the technical depth assessment (100%), but didn't fully trust its own take on career progression (78%).

Once you run this assessment over hundreds of CVs and place them on a spreadsheet or a database, you can quickly sort and filter the data to surface candidates with LLM experience, job hoppers, or people with strong technical knowledge. The confidence scores are useful if you're integrating Jev into a workflow: you can automate the next step on tasks with high confidence scores and send the lower ones to a human for review.

But this is just the tip of the iceberg.

## What can you use Jev for?

Jev works best as a part of a system or workflow where you need to make complex decisions that don't fit a clean conditional statement, or that would otherwise be too expensive and slow to do using an LLM. This model is new, so most of what we have right now is demos and brainstorming. Here are some examples:

- **Model routing, just before LLM inference.** Jev looks at the request, assesses complexity, and then forwards the request to a cheaper or stronger model based on it. This [optimizes token spend](https://zapier.com/blog/minimize-ai-spend/) without sacrificing output quality.
- **Customer support. **The model screens the content of the message for signals related to topic, urgency, and sentiment. You use these signals to pick the next-best action.
- **Labeling large amounts of data.** Received thousands of proposals for a project? Label them quickly with Jev, and sort by the ones that fit your criteria closely.
- **Checking AI output. **Jev can score outputs to find harmful tool calls and low-quality answers.
- **Protecting a network.** The model can quickly judge which actions are probably safe and can run and which aren't safe and need to be blocked. The network itself can be configured to automatically protect itself based on Jev's outputs, adding a layer of adaptive security.
- **Real-time decision-making for simple robots.** Jev's speed and efficiency can be used to improve the behavior of software robots by introducing a decision layer before each action. See a [demo of Jev playing the famous shooter Doom](https://typesafe.ai/blog/introducing-system-one-models-and-jev#:~:text=Doom).

Beyond use cases, the juicier problem to think over is where to place Jev in your system. I recommend you slot it in places where your conditional logic usually fails or struggles, especially if the inputs are unstructured (free text). It also does well in branching and routing nodes, as it can take the current state, make a decision on it, and direct the workflow to where it needs to be.

Since it's so fast and inexpensive, you can also audit your [human-in-the-loop](https://zapier.com/blog/human-in-the-loop/) checkpoints and test whether Jev can accurately reason through the decision the human is supposed to make. This can help either completely automate the node in question or, at least, provide a recommendation to the person who's making the call.

It also does well in classification tasks, helping comb text for meaning or signals, as seen in the CV screening playground example. Jev's output can help decide what's the next step based on the meaning of the text, whether that's asking an LLM to generate text, search for a help document, or send an email to a human manager.

## Jev vs. LLMs

Jev isn't meant to replace LLMs: it can't generate text or images, and you can't chat with it. Its sole job is to evaluate a state based on your questions. And as a System One model, it focuses on doing so quickly and without killing your budget.

It's consistently faster and more accurate when compared with top LLMs on the market. It can output a decision between 70ms and 500ms, and adding more questions doesn't slow down the decision process. For comparison, recent models from Anthropic and OpenAI can take between 3 and many hundreds of seconds to produce a response, sometimes hallucinating the output in the process.

In terms of cost, Jev charges $0.042 per million input tokens. The output costs so little that it's pointless to meter, according to founder Diogo Almeida—so it's free. Compare that to, for example, Claude Opus 5.5, which is $4 per million input tokens and $20 per million output tokens. Pretty stark.

In a [WikiRace demo](https://typesafe.ai/blog/introducing-system-one-models-and-jev#:~:text=Wikiracing), where models can only use on-page Wikipedia links to go from a start page to a goal page, Jev went from Baseball to Sun in 0.419 seconds for $0.047. Compare that to:

- Claude Sonnet 5: 3.724 seconds for $3.31
- Claude Haiku 4.5: 4.975 seconds for $1.03
- GPT-5.6 Terra: 9.453 seconds for $2.04 cents, with one hallucination

## Jev limitations

And now, the unglamorous part. The first limitation is a benefit with a trap: Jev can't hallucinate. This doesn't mean that it gets the response right every time—in fact, it scores 67.8% in accuracy. "No hallucinations" means that the model always returns the response in the same structure, so your system doesn't run into errors.

The content of the response itself—the scores and choices—can be inaccurate, especially if the input contains numbers or double-negative statements. Jev doesn't have multi-step reasoning like most frontier LLMs, so it can't decompose its thinking to improve accuracy. It also can't explain how it came to each conclusion, limiting its usefulness for debugging its own behavior.

Also, Jev only processes text, so you'll have to convert your audio, images, and video to descriptions before feeding them to the model. And, finally, it's still vulnerable to adversarial prompts, although TypeSafe is working on it. This means that malicious instructions can hijack Jev's reasoning; depending on the logic that you've set up based on the output, this can have serious consequences if you don't have strong guardrails.

A final tip: when setting up choice questions, make sure you don't back Jev into a corner. Include an option for "other," in case the input doesn't neatly fit any other category.

## How to get started with Jev

Jev is officially available for anyone to use:

- Go to the [TypeSafe AI](https://typesafe.ai/) website, and click to create your account.
- Open the [documentation](https://docs.typesafe.ai/introduction), and read up on the fundamentals.
- Access the [playground](https://console.typesafe.ai/playground) to start structuring your first questions, passing a state, and reading the results.
- When you're ready to build, grab the [agent skill](https://docs.typesafe.ai/agent-skill) and [create an API key](https://console.typesafe.ai/keys). Right now, TypeSafe offers $5 worth of free credits every month; remember to top up when you find a good use case and start using it heavily.

Really, Jev is accessible for anyone who can call an API and structure a JSON body. While that means that it's in reach of non-technical or semi-technical users, it still requires a good deal of systems thinking. You need to discover the best place to integrate it with existing systems and how to use the output to turn it into actions.

While there's no native integration with Zapier yet, you can use [API by Zapier](https://zapier.com/blog/api-guide/) to make a call to Jev and get the results directly inside your workflow. Once you have the decision data, use the [Filter by Zapier](https://zapier.com/blog/filter-by-zapier-guide/) action to continue the workflow based on Jev's decision. The rest can run deterministically, so you're not burning through tokens.

## Jev FAQ

### What is a System One model?

A System One model is an AI model that's fast and instinctive, as opposed to System Two models, which take a slow and deliberate approach. These terms are borrowed from Daniel Kahneman's _Thinking Fast and Slow_. Jev is framed as a System One model—it focuses on making decisions quickly and without high cost.

### Is Jev an AI model?

Yes, Jev is an AI model, but it's not a large language model (LLM) like most people are used to. It's a decision-making model from TypeSafe AI. Unlike LLMs, it doesn't generate text or images and can't chat. Its only job is to evaluate something based on your questions and return an answer with a confidence level.

### Can Jev process audio, images, or video?

Not yet. Jev only processes text, so you'll have to convert your audio, images, and video to descriptions before feeding them to the model.

**Related reading:**

- [Deterministic AI: What it is and when to use it](https://zapier.com/blog/deterministic-ai/)
- [What is AI orchestration? A guide to intelligent systems](https://zapier.com/blog/ai-orchestration/)
- [AI workflow automation: What it is + how to get started](https://zapier.com/blog/ai-workflows/)
- [Types of AI agents to orchestrate your workflows](https://zapier.com/blog/types-of-ai-agents/)