Hello friends, I am Jin Chenma.
Let me start with a question: In terms of the content they process, what are the common types of large AI models we usually encounter?
Most people are familiar with text, images, audio, and video. Over the past few years, various vendors have continuously competed and iterated in these directions, making capabilities stronger and competition fiercer.
After seeing so many updates, I kept wondering: Besides making existing models stronger, will new model forms emerge?
Recently, a model called Jev started going viral. At first, I thought: Is this just another company releasing a new large language model?
But after digging deeper, I found this model truly impressive.
Behind it, TypeSafe AI proposed a class of models called System One Models, specifically designed for judgment tasks in software. Jev is their first public model.
The previous categories (text, image, audio, video) were divided by content type; this time, they changed the angle: taking "making judgments" as a standalone task and designing a model around it.
I think this direction could have a profound impact on the future development and division of labor in AI models.
In this article, I will explain clearly what Jev is, how it differs from standard LLMs, where it can be used, and how to get started.
Starting with the QR Code Analogy
How to understand Jev? Imagine you want to generate a QR code.
Normally, you would use a QR code generator tool. But suppose you hired an artist who can draw anything, asking them to draw the QR code pixel by pixel.
Of course, this artist is skilled and can do it. But generating a QR code has dedicated tools. You just need a functional QR code, not a landscape painting along with it.
Similarly, comparing Jev to Large Language Models:
LLMs can write articles, code, and discuss complex problems. If you ask an LLM to read a comment and judge the user's sentiment, it can certainly do that.
But if the task only requires a choice or a score, consider: Can we create a faster, cheaper, and programmatically accessible model specifically for such tasks?
This is exactly what Jev does.
It gives up free-form text generation to specialize in judgments with clear answer scopes. For example, if you provide four options—"Satisfied," "Dissatisfied," "Mixed," "Undetermined"—it selects one and provides probabilities for each option.
Just as QR codes have dedicated tools, tasks requiring only choices and scores can be handled by specialized models. According to official introductions, Jev's optimization for these judgment tasks reduces response time and call costs.
For instance, filtering massive e-commerce comments daily requires judging sentiment, urgency, and handling methods. Faster, cheaper judgments reduce overall wait times and costs. Programs receive results and proceed with classification or human handoff.
The Origin of Jev
Who created Jev? Why build a model solely for judgment?
Jev comes from TypeSafe AI, founded by Diogo Almeida, who previously worked on chat model research at OpenAI.
He focused on a problem: AI is great at chatting, but why isn't it easy to integrate these capabilities into software for automated tasks?
Software excels at executing explicit rules. If condition A is met, do action B. But many real-world judgments are hard to pre-define with rules.
Like reading comments. Which expressions are complaints? Which are jokes? Which seem positive but contain hidden criticism? It's hard to cover all user speech patterns with a few rules.
TypeSafe wants to make semantic judgment a callable component. When a program needs to understand text or choose the next step, it delegates this small task to the model, gets the result, and continues execution.
They call these models System One, borrowing from the concept in Thinking, Fast and Slow. Think of it as the fast, intuitive judgment part.
The name Jev comes from economist Jevons. The team's expectation is straightforward: The lower the cost of intelligent calls, the more places people will use them.
Some steps previously felt too expensive for a single AI call. If judgment is fast and cheap enough, it becomes worth reconsidering.
How Does Jev Differ from LLMs?
Making software calls for AI judgment cheaper and easier is a good starting point. But existing LLMs can also judge and return structured results. Why build Jev?
First, let's see how LLMs deliver judgment results to programs.
LLMs support structured output, meaning answers fit into predefined slots. For example, one slot for sentiment, another for urgency, another for handling method. The program knows what each position represents.
You might know JSON, a common format for structured data. Developers can constrain LLM outputs to follow specific formats.
So, looking only at whether the final output is text or JSON doesn't reveal the main difference between Jev and LLMs.
The difference lies in how the model generates the result.
Standard generative LLMs typically produce answers token by token. Tokens are small fragments of text processed by the model. Even if you request fixed-format data, it usually generates the result step-by-step.
Jev uses a specialized output method for judgment tasks, providing multiple judgments and probabilities in parallel. You can ask several questions about the same comment and get all results in one request.
This output difference relates to speed and cost mentioned earlier. Software processing massive data daily incurs significant costs even for small steps. Agents, which call tools and execute continuous tasks, need to repeatedly decide the next step. Response speed and call cost directly affect software design, operational expenses, and user experience. Some steps previously skipped due to slowness or high cost can now include AI judgment.
There is also output stability. We define a set of options, and it returns results within that scope, facilitating downstream program processing.
Three New Features of Jev
The core of Jev lies in three new features. Their design logic is interesting and worth examining.
Briefly, Choice makes selections from given options; Score assigns ratings based on criteria; Noul judges the probability of a statement being true.
Here, I'll use the official Playground to demonstrate these features with a practical example.
Let's use e-commerce comment processing. Suppose you run an online store receiving daily customer reviews. You need to gauge satisfaction, identify issues needing follow-up, determine handling methods, and prioritize urgent cases.
We will submit this comment to Jev:
"The product is good, but shipping took ten days, and customer service didn't reply."
We will use the three features to judge this comment and see the results.
Choice: Making Selections
First, ask: What is the overall sentiment?
Options provided: Satisfied, Dissatisfied, Mixed, Undetermined.
Result: "Mixed."
This is easy to understand. The user praises the product but complains about logistics and service. Choosing only "Satisfied" or "Dissatisfied" loses part of the meaning.
Similarly, we can ask: How should this comment be handled next?
Options: "Hand off to human," "Auto-reply," "No reply needed." Rule added: Unresolved service complaints require human follow-up.
Result: "Hand off to human."
Notice, the content of the multiple-choice question can vary. Sentiment, department, next action—all can be framed this way. Options are provided by us; Jev judges based on material and requirements.
Score: Assigning Ratings
Next, ask: How urgent is this comment? How quickly must we follow up?
Before scoring, define standards. Three levels set here:
- 0: General review or simple inquiry, no unresolved complaints.
- 1: Unresolved logistics or service complaint, but no safety issues, major losses, or tight deadlines.
- 2: Explicit safety issues, major losses, or tight deadlines.
Jev returns 1, indicating medium urgency per this standard.
Scores depend heavily on your provided standards. You can switch to evaluating reply quality or relevance, but you must define what constitutes good or bad.
It can also return fractional scores between levels, not just integers.
Noul: Judging Statement Truth
Finally, give it a statement:
"The user explicitly requested a refund in the comment."
This type returns a probability between 0 and 1, representing the likelihood the statement is true.
Result: 0.03 (3%).
The user is unhappy, but didn't explicitly ask for a refund. So, the model gives a low probability to "explicit refund request."
Looking at all returned results together clarifies the picture:
These four questions were submitted together, yielding all results at once. The API reported a model evaluation time of approximately 85 milliseconds.
Now, the program has usable information: sentiment category, routing target, priority level, refund intent. Processing can continue based on these results.
What Can Jev Be Used For?
We processed one comment. On an e-commerce platform with massive daily volume, this usage expands further.
First, statistics.
Which users are satisfied? Who complains about logistics? Which issues need customer service? The model judges meaning; the program aggregates counts and displays categories.
Second, initial filtering to decide what needs deeper processing.
General reviews go to stats. No-response-needed items skip individual replies. Unresolved issues go to humans. Auto-replies suitable for LLM generation are passed to larger models with context.
Previously, having an expensive general LLM screen everything first incurred high initial costs. Now, Jev handles the front-end screening, leaving deep processing for LLMs.
Can keyword filtering work?
Partially, but keywords miss context.
Example:
"Quality is really great, fell apart after one day."
Matching "great quality" misclassifies this as positive. Reading the whole sentence reveals sarcasm.
Jev still takes natural language input and understands full meaning. Its specialization is in task type and output format, not just keyword matching.
Turning results into actions requires external programs.
Return "hand off to human," program queues for manual review. Return "auto-reply," program calls LLM to generate response. Actions are executed by workflow rules and tools.
In Agents, this external system organizing model calls, tools, and workflows is often called the Harness. Jev fits into the judgment positions within the Harness, helping choose next steps.
Therefore, I believe Jev and LLMs are complementary, not mutually exclusive.
Specifically, replace LLMs with Jev for classification and scoring. Later, for writing copy, code, or complex multi-step reasoning, rely on LLMs.
Thus, a system can use different models for different stages, combining capabilities organically.
How to Experience Jev?
The most direct way is opening TypeSafe Playground.
Log in, put text to analyze in State (material for judgment). Set questions in Questions, select judgment type, fill in options or scoring criteria, click Run to see results.
Try the previous comment or swap in a positive review to observe changes.
To integrate into your software, use the API.
API allows one software to expose capabilities for another. Get an API Key from the console. Your program sends materials and questions with this credential, receives results, and executes subsequent logic.
Official SDKs are also provided, wrapping common interface functions for developer convenience.
Pricing: $0.042 per million input tokens, output free. Input includes materials, questions, and criteria. High-volume comment filtering can use this pay-per-call model in existing flows.
The Future of Specialized Judgment Models
After researching Jev, I was impressed: Someone should have done this long ago, but nobody did.
I think this approach is correct. While everyone races to boost large model performance, TypeSafe AI opened a new track, creating customized models for structured data, probabilistic judgment, selection, and decision scenarios.
Cost and speed benefits are friendly to Agents. Waiting for large models to slowly return data is inefficient in some contexts.
I believe other vendors will likely follow this trend, building specialized models for Agent judgment stages.
An Agent can have models for fast judgment, others for complex thinking/writing/code, plus image/audio/video models, working together.
When judgment is fast and cheap enough, we can place AI in more places previously deemed not worth the call. For me, this is the most exciting part of Jev's direction.
