AI Tools
What is Jev and how to use it
Jev's launch post on X received nearly 40 million views in less than a week.
If you've seen people talking about it, you might be wondering whether it's something you should be using too.
In this article, we'll work through the following questions, with examples and a TypeScript demo.
- What exactly is Jev?
- How does Jev compare to LLMs?
- How does it fit alongside Cursor, Claude Code, and Codex?
- How much does it cost?
- How does it work?
- How do you get started?
- How do you use Jev with TypeScript?
- When should you use Jev, and when should you avoid it?
What is Jev?
Jev is an AI model from a company called TypeSafe. You give it information, ask questions about it, and get back structured answers your application can use.
The simplest way to think about Jev is as a smart if statement.
Let's say you run an online store and want to offer free delivery when someone buys three or more items. That's straightforward to write in code.
You check the number of items, and if it's three or more, you offer free delivery.
But now let's say you want to flag messages from customers who sound frustrated. How would you write that condition?
You could search their messages for words like “angry” or “frustrated.” But a customer might send you this message.
I've contacted you three times, and I'm still waiting.
They haven't used the word “frustrated,” but you can see what they mean.
With Jev, you can ask whether the message expresses frustration and get back a value your code can act on. You still decide what the application should do. Jev helps evaluate the meaning of the message.
A closer look at the definition
TypeSafe describes Jev as a System One model built for fast, structured decisions that software can use directly. Let's break that down.
System One: a focused judgment
The name is inspired by the two ways of thinking described in Daniel Kahneman's Thinking, Fast and Slow. System One is fast and intuitive. System Two is slower and more deliberate, where you work through a problem step by step.
Recognizing frustration in our customer message is a quick judgment. Solving a difficult math problem takes more deliberate reasoning. TypeSafe takes inspiration from the first kind of thinking. System One is its model category for focused judgments, and Jev is its first public model.
Fast, structured decisions
TypeSafe reports end-to-end response times of 70–500 milliseconds. Structured means you define the kind of answer you need, such as a probability or a category, and Jev returns that answer as data. For our customer message, we could ask for the probability that the customer sounds frustrated.
Software can use directly
Your application can check that probability and decide whether to flag the message for review. Jev makes the judgment, and you write the rules for what happens next. We'll see how to do that in the TypeScript example.
Where does the name Jev come from?
The name Jev has a different origin. It comes from William Stanley Jevons, who observed that more efficient steam engines could lead to greater coal consumption. Cheaper operation encouraged people to use the engines more. TypeSafe expects cheaper AI decisions to make more applications practical in a similar way.
How does Jev compare to LLMs?
Now, you might be wondering, couldn't models like OpenAI's GPT, Anthropic's Claude, or xAI's Grok evaluate the same customer message?
Yes. Those models can make judgments and return structured output too. The difference is what Jev is designed for.
With those models, you could ask whether the customer sounds frustrated and then ask them to write a reply. You could also use the same model to explain a concept or generate code.
Jev, however, focuses on just the judgment. You give it the customer message, and it tells you how likely it is that the customer sounds frustrated. It doesn't write a reply or explain its answer.
Jev is still an AI model, but TypeSafe calls it a System One model rather than an LLM. It's built around making judgments, and that also changes how it produces its answers.
Why can it be faster?
An LLM generates its response one token at a time. Jev computes answer probabilities in parallel. It can also evaluate several independent questions about the same information in one request.
For our customer message, we could ask whether the customer is frustrated, what they want, and how strongly they express frustration. Jev can evaluate those questions together in one request. Its approach to producing answers is one reason it can be faster and less expensive for decision tasks.
Here's one example from TypeSafe's demo.
That puts Jev at about 1/170 of the cost for this request. TypeSafe's demo uses GPT's default reasoning setting and a short input that favors Jev, so treat it as an example rather than a general speed or cost ratio.
How does Jev fit alongside Cursor, Claude Code, and Codex?
Cursor, Claude Code, and Codex help you build software. Jev is a model you can call from that software.
For example, you could ask a coding tool to add customer-message classification to your app using Jev. The tool writes the integration. When a message arrives, your app calls Jev to evaluate it. They serve different roles and can be used together.
How much does Jev cost?
As of September 20, 2026, TypeSafe lists Jev at $0.042 per million input tokens, equivalent to $42 per billion input tokens. Output tokens are free. Check the model pricing page for the latest rate.
What does that mean for our customer-message example? At an average of 500 input tokens per request, including the message and question, one dollar would cover roughly 47,000 messages.
500 input tokens × $0.042 / 1,000,000 = $0.000021 per request
$1 / $0.000021 ≈ 47,619 requests
We're assuming 500 tokens here. We haven't measured that count for the one-sentence example. Longer messages, more questions, and detailed criteria increase the input. You can use the token usage returned with each response to calculate your actual cost.
For an application that checks every incoming message, a small judgment can run frequently without adding much to the bill.
How does Jev work?
Let's look at what you send to Jev and what you get back. You give it some information and ask questions about it. Jev then returns an answer for each question.
Input: state and questions
The input has two parts. You send the information you want Jev to look at and the questions you want it to answer.
TypeSafe calls this information the state, and the state can be plain text, a JSON object, or an array. Going back to our customer example, we can put the message in a JSON object.
That message is the state we're giving Jev. What do we want to know about it? In this case, whether the customer sounds frustrated.
For each question, you choose a question type based on the kind of answer you need. You choose this when you send the request, so Jev knows what kind of answer to return.
The three question types
Noul: a yes-or-no judgment
The first question type is Noul. You use it for a yes-or-no question, like the one we've been asking about our customer.
Does this customer sound frustrated?
With Noul, you get a number between 0 and 1 that tells you the probability that the answer is yes.
Let's say Jev returns 0.95. That means it estimates a 95% probability that the customer sounds frustrated. A value close to 0 means it favors no, while 0.5 gives equal probability to yes and no.
So a low value doesn't mean Jev is unsure. It means Jev thinks the answer is likely no. We're using these numbers to understand the response, rather than showing an actual result for our message.
Choice: select from your options
The second question type is Choice. You use it when you want Jev to pick from a set of options you provide.
For our customer message, we could ask what the customer wants and give Jev these options.
- Asking for an update
- Requesting a refund
- Requesting a replacement
- Something else
Jev picks an option and also returns the probabilities for the options. Since you're deciding which options are available, it's useful to include “something else” for messages that don't fit your categories.
Score: evaluate a defined scale
The third question type is Score. You use it when you want to evaluate something on a scale.
For our example, we could ask how much frustration the message expresses. We can describe three levels for Jev to use.
These descriptions tell Jev what each level means. That gives it more to work with than simply asking it to “rate the message.”
The levels start at zero. Jev assigns probabilities to them and returns a weighted average, so the score can fall between two levels. If it assigns equal probability to levels 1 and 2, with none to level 0, the score is 1.5.
Asking several questions together
All three questions can go into one request because they evaluate the same message. Jev evaluates them independently, in parallel.
What does independently mean here? One question doesn't get to read another question's answer. Each question has to work from the information you've provided in the state.
If a later decision needs an earlier answer, your code handles that sequence. For example, you could first classify a message, then fetch the customer's order details before asking another question. The second request would include the information needed for that next decision.
This lets you build a larger workflow from smaller judgments. Your code gathers the information and manages the steps, and Jev answers the questions along the way.
The question-type documentation explains the request fields and how these types fit together.
Output: answers and usage
Now let's look at the response. You get an answer for each question, matched to the name you gave that question in the request. What that answer contains depends on the question type you chose.
Choice and Score also include a confidence value, which reflects how the probabilities are distributed across the options or levels. Noul doesn't have a separate confidence field. You look at how strongly its probability favors yes or no.
You can use these values to decide whether to act on an answer or leave it for someone to review. To choose a threshold, try messages like the ones your application will actually receive and check the results.
You also get the model version and token usage, so you can see which model handled the request and how many tokens it used.
How do you get started with Jev?
Go to the TypeSafe website and sign up. There's no longer a waitlist, and you get $5 in credit to start with. That's enough to try thousands of requests.
Once you're in the console, open the Playground. You can try Jev here without writing any code. Let's use our customer message and enter this JSON object as the state.
For the question type, choose Noul and enter the following question.
Run the request and inspect the returned probability. The closer it is to one, the more strongly Jev judges that the message expresses frustration. You can change the message or add questions to explore the results.
Once you've tried it in the Playground, create an API key in the console's API Keys section. Next, we'll use that key to make requests from TypeScript with the TypeSafe SDK.
Using Jev with TypeScript
The demo repository contains two examples. We use demo.ts for a Noul question and all-questions.ts for all three question types.
Set up the demo project
With Node.js 22 or later installed, clone the project and install its dependencies.
Create a .env file in the project root with your API key.
The run commands load this file, and the SDK reads TYPESAFE_API_KEY from the environment. The project ignores .env in Git, so your key stays out of the repository.
The dependencies include @typesafe-ai/sdk, TypeScript, Node.js types, and tsx. The project uses ES modules, and tsx runs the TypeScript files directly.
Make a Noul request
Open demo.ts and set the message to our frustrated-customer example. Here's the complete request, including a check for the API key.
client.systemOne() sends the state and questions to Jev. We've named the question isFrustrated, which lets us find its answer in the response.
The text inside noul() is the question Jev evaluates. Notice the backticks around message. They highlight the field name in the question. Since the surrounding string uses double quotes, these backticks are just text. JavaScript doesn't use them to insert the message's value.
Run the example with the following command.
The npm command loads .env and runs the file with tsx. The response contains an answer named isFrustrated, matching our question name. Its noul field holds the probability of yes.
The script also prints how long this request took from your machine.
Now change the message to something more positive.
Run the command again and compare the probabilities. The question stays the same, and only the state changes.
Add Choice and Score
In all-questions.ts, we use the original message and include all three helpers.
The request in that file looks like this.
Here, requestType asks what the customer wants, and frustrationLevel asks how frustrated they sound. We're giving Jev the options for the first question and the descriptions of each level for the second.
Notice that we're still making one call. All three questions use the same state, so we can send them together.
Run the completed example with the following command.
You can access the main results using these fields.
The printed response also contains the probabilities and confidence values for Choice and Score.
Use an answer in your application
At the bottom of all-questions.ts, a simple condition uses the Noul result.
Here, 0.8 is an illustrative threshold. You would tune it using your own messages and the kinds of mistakes you want to avoid. A result below the threshold simply leaves the message in the normal queue. It doesn't prove that the customer is happy.
We've used a console message to keep the example small. The same result could drive a support-queue update, an indicator beside the message, or another step in your application.
When should you use Jev, and when should you avoid it?
Jev is worth considering when your application needs a focused judgment about information. Here are a few examples.
- Routing customer requests to the appropriate team.
- Classifying documents into known categories.
- Checking whether a passage supports a claim.
- Selecting which model should handle a request.
- Making quick judgments for a game or interactive interface.
It can also help decide the next step in an agent workflow. Your code determines which actions are allowed at the current step, and a Choice question asks Jev to select among them using the available state and goal. Your application then carries out the selected action. Jev supplies a judgment within the workflow, and the surrounding code still controls what it can do.
TypeSafe's use-case guide has more examples.
How we're using Jev in Agent-Native
We're using Jev in Agent-Native, a framework for building agentic applications, to help choose the tools, skills, and resources an agent needs for a request.
As an application grows, its agent might have access to many tools and skills. Including all of them in every request adds more information for the LLM to process, even when most of it has nothing to do with what you're asking.
With Agent-Native, Jev evaluates each prompt and helps select the relevant tools, skills, and resources to include in the LLM's context. The LLM then works on the request with that information available. Jev handles the selection, while the LLM handles the reasoning and generation.
This is a useful way to combine the two. Jev makes a focused decision that keeps unnecessary information out of the context, which can reduce token usage and help the agent work more efficiently.
When should you use something else?
If you need to write a reply, summarize an article, or generate code, use a model that generates text. Jev can judge information involved in that task, but it won't write the result for you.
For tasks that need extended reasoning, such as solving a complex math problem or planning many steps ahead, TypeSafe recommends larger reasoning models. A quick judgment about the next action is different from working out an entire plan.
And if you can calculate the answer exactly in code, do that. You don't need AI to check whether a basket contains three items. The same applies to arithmetic, counting, and comparing dates. TypeSafe documents these and other weaknesses on its limitations page.
When you're deciding whether to use Jev, ask yourself, do I need a judgment about this information, can I define the possible answers, and does speed or repeated use matter? If so, start with one small decision and test how Jev handles your examples.
Try it with your own data
The customer-message example gives you a small place to start. Replace the message with examples from your application, keep the question fixed, and compare the results. Include clear cases and ambiguous ones before deciding how your code should respond.
For support messages, try a polite complaint, a strongly worded complaint, a neutral request, and a message that doesn't give you enough context. Write down what you would expect for each one. Then check where Jev agrees, where it makes mistakes, and whether your review threshold catches the cases you care about.
You can also rephrase a message without changing its meaning and compare the judgments. This checks whether similar information gets a similar interpretation. You're looking for consistency in the judgment, rather than an identical numeric result every time you repeat a request.
As you add questions, choose Noul for a yes-or-no judgment, Choice for a category, or Score for a defined scale. Keep each question focused on a decision you actually need.
You can build on the demo source code and use the TypeSafe documentation as a reference.
Share
