Have you heard of “Jev” by TypeSafe AI - the latest AI model that’s taking the world by storm?
Oh it can’t generate text, can’t chat with you, can’t even give you long answers but it does few things good and it does better than any other.
It’s one of the first models built for “reliability” .
Before diving deep into Jev, let me showcase what I have built with Jev. Check out this video below:
In this video, I am using Jev to recommend the right tools. It would actually replace the chatbot that I have with better and faster answers.
It’s quite fascinating. I'll go into much more detail on how it works later in the article. Let’s first understand what is Jev.
If you haven’t read my previous articles, check out these:
What is Jev?
Jev is the latest model released by TypeSafe AI - a company built by the team behind the ChatGPT. Jev is actually not a traditional LLM; it doesn’t generate text. Developers provide structured context and questions, and Jev returns typed answers with calibrated probabilities.
This video will explain to you a lot more than any other tutorial out there.
Source: Original post by Prince does AI
TypeSafe AI is a San Francisco AI startup building “machine-native” intelligence for software rather than conversational chat. Its core idea is that AI should return structured decisions, probabilities, and confidence scores that applications can act on directly.
It’s what the TypeSafe AI team calls a “System One” model:
System One models are a class of AI models built to make fast, structured decisions that software can use directly. A System One model evaluates a state and returns typed answers and probabilities.
The model class name of System One draws on the distinction between fast, intuitive System 1 thinking and slow, deliberate System 2 reasoning - which is written in the famous book “Thinking, Fast and Slow” - by Daniel Kahneman .
System One is all about fast thinking. Jev is all about that. It’s primary use case is quick decision-making.
BTW the name “Jev” is inspired by Jevons’ paradox—now, what is the Jevons paradox:
“Jevons paradox describes how efficiency improvements can lower the cost of using a resource, increasing demand so much that total consumption rises rather than falls. The idea was introduced by economist William Stanley Jevons in 1865.”
What’s interesting is not only does it give structured responses, but it’s also cheap and, most importantly, has almost no hallucinations (at least that’s what they claim)
Input Cost: $42 per billion input tokens
Output Cost: $0 (yes, you read it right - it’s zero)
In order to build this, they have tried to use a different architecture - Reinforcement Learning for Calibrated Decisions, or RLCD.
TypeSafe describes Reinforcement Learning for Calibrated Decisions (RLCD) as the training method behind Jev. It trains Jev to return structured decisions with probabilities, rather than generate free-form text. The goal is for those probabilities to reflect how likely each decision is to be correct.
The goal is to let software act automatically when confidence is high and request human review when confidence is low.
TypeSafe claims Jev can operate in under 100 milliseconds and be up to 100 times faster and cheaper than comparable frontier models. Its website claims a specific workflow was 193.6x faster and 444.6x cheaper than an LLM-based approach.
Three Primitives that drives AI decisioning by Jev
TypeSafe exposes three AI types of primitives. Each of the primitives are modular, composable, structured, reliable, and fast. Each asks a different type of question and returns a different type of answer.
Choice : “Which option is the best fit?” For example, it could route a support ticket to billing, technical support, or sales. Jev returns the selected choice, probabilities for every option, and a confidence score.
Score: ‘Where does this fall on an ordered scale?’ For example, it could rate customer frustration as calm, concerned, frustrated, or very frustrated. Jev returns a probability for each level, a probability-weighted score, and a separate confidence value. With four ordered levels, the score ranges from 0 to 3 and can fall between levels depending on the number of options defined in the input criteria. Confidence comes back in Jev’s response; you do not add it to the request. It reflects how concentrated the probability distribution is, not a guarantee that the judgment is correct.
Noul: ‘Is this statement true?’ It returns a single number from 0 to 1: the probability that the answer is yes. A value near 1 means yes is likely, near 0 means no is likely, and near 0.5 means Jev is uncertain.
These outputs are designed to plug directly into software. A program can use a Choice to select a route, a Score to apply a threshold, or a Noul as a probabilistic if-statement. Developers can also use confidence and probabilities to decide when Jev should act automatically and when a human should review the result.
Three software architectures—where does Jev fit in
TypeSafe is primarily designed for building AI-powered software, where code owns the workflow and AI handles narrow, structured decisions.
Traditional Software
Traditional code is a complex decision tree made from simple software primitives. Because each primitive is reliable, developers can compose them into higher-level abstractions.
LLM Agents
An agent processes instructions and chooses its next step. This works well when a person is monitoring the process, but every loop introduces another opportunity to go off the rails.
AI-powered software
Code handles deterministic work and owns the control flow. The model appears only where the system needs programmable common sense or needs to interpret unstructured data. Each AI task is kept atomic and constrained.
What I built with Jev - TheToolNerd Library
I have a tools directory : TheToolNerd Library , it’s a directory with 1000+ tools that I keep updating on a regular basis. I also have a chatbot there for people to ask any questions and get answers by looking at my database of these tools.
That said, it’s not a great experience. Jev has inspired me to do something different, and I feel it is much faster than the chatbot experience. To be honest, it’s a replacement for a chatbot.
I wanted to do two things - first, classify the existing database properly, as it’s been a while since I did that, and next was to make it easy to recommend the right tools for specific topics
Phase 1: Classification of existing tools database
I have more than 1000+ approved tools, and the categories need to stay useful as the directory grows. Doing this by hand would take too long.
For each tool, I send Jev a small state with its name, slug, description, and up to eight features and use cases. The goal is to give Jev enough context to make a focused judgment.
In the same request, Jev answers several questions:
Choice picks one primary category from a fixed list, such as AI Coding, Design, Video, or Productivity. There is also an “Other” option for tools that do not fit well.
Nouls check for secondary categories that can overlap, like sales, social media, or voice.
Scores rate three qualities on a four-level scale: how well-known a tool is, how clear and credible its product is, and whether it belongs on the homepage.
await client.systemOne({
model: 'jev-latest',
state: {
tool: {
id: 59,
name: 'v0 by Vercel',
slug: 'v0-by-vercel',
description: 'Generate UI from natural language…',
features: ['…'], // up to 8
use_cases: ['…'], // up to 8
},
},
questions: {
primary_category: choice('Which single category best fits this tool? …', {
'AI Coding': 'AI coding assistants and IDEs',
'Vibe Coding': 'Prompt-to-app builders for non-devs',
// …full taxonomy
Other: 'Does not fit the listed categories well',
}),
is_video: noul('Is this primarily a video generation or video editing tool?', {
true: 'Core job is making or editing video.',
false: 'Not primarily video.',
}),
fame: score('How famous / category-defining is this tool among builders?', [
'Obscure — few people in the space would recognize it',
'Known in a niche — recognized by specialists',
'Well-known — many practitioners know it',
'Household in AI/tools — widely recognized brand',
]),
// + more Nouls / Scores in the same call
},
});The scores and flags are saved in Supabase as fields such as jev_fame, jev_sharpness, and jev_homepage_worthy. They sit alongside my editorial choices.
I ran the classifier across 1,227 tools. It used 2.16 million input tokens and 547,000 output tokens. Based on Jev’s input price at the time, the run cost about nine cents.
Phase 2: Recommendation of tools in milliseconds
The second phase is the part you will see on the homepage of The Tools Directory . Instead of asking a chatbot a question and waiting for a paragraph, you can describe what you need and watch the matching tools move to the top.
Here’s what happens when someone searches for “vibe coding tools.”
First, my code builds a shortlist. Jev doesn’t have to score all 1,200 tools for every search. I tokenize the query, map words like “vibe” to the categories we use in the directory, and gather around 64 possible matches. The shortlist also uses category labels, well-known tools, and keyword overlap across names and descriptions. While someone is typing, the page can show local hints. Jev runs once the query settles, rather than on every keystroke.
Then one request goes to Jev with the search and a compact list of candidates. Each tool gets an ID, name, categories, and short description. Jev answers three questions in parallel:
A Choice compares the tools in my shortlist and returns one selected option, along with a probability for each candidate. I use the full distribution to rank the shortlist, so several strong matches can still appear near the top for a search like “vibe coding tools.”
A Noul checks whether the directory has a meaningful match at all. If the probability is below roughly 0.35, the page can say there are no strong fits instead of pretending the top result is a good one.
A second Choice returns a short intent tag, such as Notetaking, Coding, Design, or Video.
The last step is ranking, and that part belongs to my code. Jev’s Choice probabilities are the main signal, but I also use the fame and homepage-worthy scores from the classification pass:
final ≈ 0.70 × Jev probability
+ 0.25 × fame (normalized)
+ 0.05 × homepage_worthyAfter that, the code removes duplicate tools, caps the list at 36, and can add a few well-known tools from the same category if Jev found a clear cluster but returned a short list.
If you want to try it, open TheToolNerd and describe a real job you’d hire a tool for. The directory still works as a directory, but it gives you another way in: describe what you mean, and let the tools that fit rise to the top.
That’s how I’m using Jev: to classify the catalog once, then help people find the right tools in a few hundred milliseconds.
What did the community build with Jev
Jev has some fascinating use cases built by the developer community, sharing few of the interesting ones here.
My verdict
Jev is not an LLM replacement. It is a decision layer.
In TheToolNerd, it turns tool descriptions into structured catalogue features and turns human queries into ranked candidates. The model makes the judgement. Code owns the product behaviour.
Jev makes decision call in the 150-200 ms range and can run inside a real interaction, and a batch of more than a thousand tools can be classified in seconds at a small cost.
For AI products, that opens a useful design pattern:
Use an LLM when the application needs reasoning, planning, or language generation.
Use Jev when the application needs a bounded decision.
Keep thresholds, composition, fallbacks, and user-facing behaviour in code.
Go ahead and try it out !!