Why Jev became popular: When AI stopped writing answers and instead made judgments for the software.

Machine-translated with NiuTrans. Read the Chinese original.

TypeSafe AI Official Review Chart: Jev Compares to Other Models in Workflow Accuracy and Cost

Image source:TypeSafe AI's Jev Release Article。 This is the company's own workflow evaluation diagram. See below for specific comparison conditions and limitations.

An email arrived: "You've deducted money from my account twice. If it doesn't get processed today, I'll file a complaint." The customer service system's next task isn't mysterious: identify this as a billing issue, determine if it's urgent, find the order, and then decide who to hand it over to. In the past, we might have given an email to a chat model, asked it to write an analysis, or had it spit out a piece of JSON in a specified format. Now a company is asking another question:If software only needs a few judgments, why does it have to make the model write an answer first?

This company is TypeSafe AI. Its Jev, launched on September 15, 2026, targets precisely these small judgments hidden in software processes. It receives a description of the situation and a pre-set question, and returns options, scores, or probabilities that the program can read directly. For example: Is this email a "bill" or "technical support"? Did the customer explicitly request a refund? How emotional were you? These answers are then handed over to ordinary programs for processing.Release notes for TypeSafeandProduct DocumentationBoth describe it as a decision-making model for software calls.

This approach is worth looking at carefully, but it can easily be overstated. Jev is not a machine that automatically handles all complaints; It answers questions, and company procedures and employees are still responsible for verifying deductions, executing refunds, and handling exceptions.

Let's put it into a real process first.

Assume that the system has received customer emails, order records, and refund rules. Traditional chat models can also understand these materials. You can ask it to say, "Summarize the situation, give priorities, departments, and refund recommendations." It might write something that sounds like a human customer service executive, or it can return JSON as requested. The developer then reads the results into the program, checks whether the fields are complete and the values are valid, and then decides on the next step.

Jev is used more like giving it several multiple-choice questions at once:

Questions asked to the model	What might be returned?	How to use the software
Which department should this email be sent to?	Options such as billing, after-sales service, and technical support, and their respective weights.	Forward to the corresponding queue
Does the customer request a refund?	The probability of "yes"	Decide whether to initiate a refund verification
How urgent is the customer?	Scoring on a preset level	Determine the order of processing

The answers in the table only illustrate the format.hypothetical exampleThis is not the result I get when I actually call Jev. When actually deploying, the criteria for judging the problem should be clearly written, and exits such as "other" or "unable to judge" should be allowed. Just because a customer says "money was deducted twice" doesn't mean that the financial system actually made two valid deductions; Checking transaction records cannot be replaced by tone of voice.

Jev's strength lies in this interface. Developers first specify the range of answers that can be given, and the model makes judgments within that range. Subsequent programs can then be divided accordingly. It transforms information that was originally hidden in a long piece of text into values that can be used directly in the software process.Definition of three problems in official documentsYes: Choice selects one of the given options; Score scores at a given level; Noul answers a true or false question and gives the probability of "yes". The latter does not have a separate confidence Field.

What exactly is the difference between it and ChatGPT?

The strength of chat models is their flexibility. Ask it to explain a contract, write a reply, or modify a piece of code; the answer often has no fixed shape. It usually generates text gradually; Even if you end up with just one department name, you're still completing a text generation task. Jev predetermines the optional answers and question types, and processes multiple independent questions in parallel in a single request. It is not responsible for writing that email to reassure the client.

What do you need	Chat-based AI is more convenient	Jev is a more suitable scenario
Write a measured reply	Can be drafted and modified directly	Do not generate reply body
Choose a destination in a fixed department	It can be done, usually requiring constraints and checking the output.	You can return directly to the default options
Simultaneously judge more than a dozen independent small problems	You can answer in the specified format.	The design goal is to give these judgments in parallel.
Dealing with new questions without preset answers	Flexible exploration and interpretation	First, design the question and answer range.

This is to correct a common misconception: today's generative models already support structured output, tool calls, and formatting constraints, rather than just outputting a paragraph of prose. The difference between the two lies not in "the former absolutely cannot be left to the program, only the latter can," but in their main design goals, the way they generate answers, and the cost and speed trade-offs between multiple small judgments. Complex cases may not be suitable for breaking down all judgments into independent multiple-choice questions.TypeSafe documentationIt is recommended to break down questions that require multi-step analysis and then combine the answers with a program.

What are people doing with Jev now?

Jev has only been released for a short time, and the following are mainly open-source projects publicly available in the community. They are not official products of TypeSafe, and the demonstration results in the project README should not be taken as general conclusions for the production environment. However, they are well suited to explaining the location of the Jev: the Jev is responsible for making a clearly defined judgment, and the actual clicks, deletions, diversions, or orders are still done by other programs.

• Jev Ultrafast: A browser proxy. It organizes the controls on the webpage into numbered action spaces, allowing the Jev to choose "which button to click, which option to select, whether to scroll," etc. Only when you really need to input free text do you hand it over to a small language model to generate text. The Google Flights example in the project also independently examines the final page, demonstrating that it is searching for Flights, not paying for and booking tickets for users.
• Jev Review: A phased code review tool. It first assesses the risk, then selects the file type, evidence, and possible problem mechanisms, then gives a severity score and decides whether it needs to be forwarded to a specific reviewer, and finally displays the report on the local page. It itself notes that the report is a review tip, not a conclusion that a defect has been proven.
• fast-jev-compaction: A context cleaning plug-in for Claude Code. Instead of letting another chat model regenerate the entire history, it lets Jev determine which tool calls and results are still worth keeping and which can be deleted or shortened; The original text that has been retained continues to be retained as is. This is a very intuitive example of Jev making "trade-offs" rather than writing answers.
• typesafe-computer-useA macOS computer operation experiment. The program reads the screen using OCR and the accessibility tree, and then lets Jev choose the next step from a limited number of actions; The writing model is called only when you want to enter a piece of free text. It demonstrates breaking down the "operating computer" into many cheap little options, but still requiring permissions, deterministic screen reading, and safe stop conditions.
• jev-trader: A trading experiment connecting the Kuru MON-USDC order book on Monad. For each block, it asks Jev whether to buy or sell, then places a corresponding price limit order and pushes the decision and transaction results to the dashboard. By default, the project can only run simulations; Even so, this experiment should not be considered a guarantee of returns or investment advice; it is more suitable for observing the role of JEVs in low-latency decision-making.

These projects show that Jev is currently most often placed "before action": browsers prepare clicks, code reviewers prepare reports, proxies prepare context compression, and trading programs prepare orders. It's not as simple as replacing one large model with another; rather, it reduces the steps that originally required generating long answers to a few small judgments that the program can repeatedly call.

What can it do for non-software engineers?

If you're not a developer, the most common misconception is that Jev seems to be just another AI tool that requires you to open a chat window and learn prompts. In fact, ordinary users are more likely to use it indirectly in software that already has Jev integrated, rather than talking directly to Jev.

Everyday scene	What can Jev judge in the background?	The final result you see
Numerous emails and customer service messages	Is this a billing, after-sales, or technical issue? Is it urgent? Is a refund explicitly requested?	Emails are automatically placed in the appropriate queue, and ambiguous or high-risk emails are handed over to manual labor.
Invoices, reimbursements and application materials	Are the materials complete? Do you want to trigger a rule? Is additional proof required?	First, screen out any missing materials or items that need to be reviewed to reduce manual review of each item.
The information and notifications are too mixed.	Is this news important? Is it a reminder, bill, advertisement, or to-do list?	Automatically categorize, remind, or silently process instead of pushing everything to you
Other AI agents are performing tasks.	Should we continue next, which tool should we call, or should we stop and ask people?	Fewer unnecessary model calls and fewer uncertain automated actions.

These things are not done by Jev alone. When it's actually implemented, someone still needs to design the problems, options, thresholds, and follow-up actions. The software is also responsible for reading real data, recording results, and handling exceptions. For non-developers, the value of Jev is not that it allows you to learn another API, but that it makes it faster and cheaper for the customer service, office, browser, or automation tools you are using to make a lot of repetitive judgments, and it is also easier to set the boundary of "leave it to someone else if you are unsure".

Why probability is more useful than a definitive answer

Return to the duplicate deduction email. If the system only receives "yes" or "no" when determining whether a refund is explicitly requested, it is easy to take excessive actions when encountering vague wording. If you can see the weight the model assigns to "yes," the program can set rules: clearly proceed to subsequent verification; If the information is vague, please ask the customer for additional information; The key steps involving genuine refunds are still checked and executed within the company's authority.

There are two easily confused numbers here. For right and wrong questions, Noul gives the probability of "yes". For multiple-choice and scoring questions, Jev provides a probability distribution for each option or level, and also offers a probability distribution calculated from the degree of distribution concentration. confidence。 **This confidence is not "the probability of this answer being correct". **If the weights of the three departments are 90%, 7%, and 3% respectively, it indicates that the model's judgments are very concentrated; As for whether the judgment of focusing on the "billing department" is correct, real cases are still needed to test it.Official explanation of confidenceIt also clearly distinguishes between it and probability, and suggests setting different thresholds based on business risks.

There is also a word called "calibration". In layman's terms, if the model answers "yes" about 80% of a large number of verifiable similar questions, the proportion of those that actually answer "yes" should also be close to 80%. Such numbers make it easier to design the boundaries between automated processing and manual review. TypeSafe calls its training method RLCDThis means that reinforcement learning is performed on calibrated decisions. It hopes that in addition to providing answers, the model can also express uncertainty more honestly.Release NotesThis goal was explained; However, publicly available information is insufficient for the outside world to independently reconstruct the training details, nor can it be concluded that all scenarios are well-calibrated based solely on product introductions.

Where do speed and cheapness come from?

You only ask the security guard, "Can this person come in?" and he writes a one-page report first. No matter how good the report is, it's not the easiest way to work. This is an opportunity Jev wants to seize: abandon writing long paragraphs of text and let the model return multiple judgments with predefined shapes at once. According to officials, multiple issues can be processed in parallel in the same request; It publishes a service response time of approximately 70-500 ms。Product DocumentationThe method of asking questions in parallel is explained.Release NotesThe velocity range is given.

The price quoted when TypeSafe is released is per million input tokens 0.042 USDThe output is not charged separately per token. The token here can be simply understood as the unit of input content segmented during billing. Prices and latency will vary depending on the service and usage conditions. You can't use Jev's one-time categorization fee to directly compare the cost of writing a long article with a chat model. The two do different jobs.

The official report showed the highest approximate 193.6 times faster, 444.6 times cheaperThe workflow comparison, while also admitting that these figures may be at the high end of actual revenue. Its evaluation uses multiple complex workflows and refers to the average answers of two other large models, rather than having independently manually verified standard answers to all questions. The testing process is designed by our company.evaluation methodandCompany's Explanation of RestrictionsIt's worth watching in a row. Therefore, the safer conclusion is:This interface demonstrates significant efficiency potential in tasks suitable for breaking down into a large number of small judgments; The exact amount of savings needs to be measured using your own business data.

Even if you don't talk nonsense, you need to break it down and understand it.

TypeSafe claims that Jev does not produce type errors. For developers, this means that if the pre-defined answer can only be "billing, after-sales service, technical support," the model will not suddenly return a department name that the program does not recognize. This reduces format checking and retries, which is indeed valuable.

ButThe format must be correct, but that doesn't necessarily mean the content is correct.。 If the customer actually encounters a bank card pre-authorization, the model may still judge it as a duplicate charge. It may also be overconfident due to the lack of trading status in the input. When discussing "no hallucinations," the official team mainly emphasizes limited output and the inability to generate values outside the range. The reader should not read it as "not misjudging".Type guarantee and evaluation notes in the official descriptionThis separate understanding is also necessary.

A truly reliable customer service process should have a clear division of labor: the model judges the intent and urgency of the letter; Procedures verify orders and rules; If you have any doubts, hand them over to someone else; Refund execution retains authorization and records. This way, even if the model makes a mistake once, it won't directly turn into an erroneous payment.

Why is it called System One? Will it replace the chat model?

"System One" borrows from the psychological contrast between "fast, intuitive judgment" and "slow, cautious thinking". TypeSafe uses it to name its model categories; Jev is named after economist William Stanley Jevons, and the company uses it to express the expectation that as intelligent judgment becomes cheaper, people may use it in more places.See the end of the release notes for the origin of the naming。 This is a product positioning and analogy, and does not mean that Jev's internal mechanisms are equal to human intuition.

I prefer to think of it as a new tool next to the chat model. Writing reassuring emails, explaining complex policies, and studying an unprecedented dispute still requires models and people who can organize language and conduct analysis. A lot of repetitive classification, scoring, routing, and verification might be more suitable for an interface like Jev. Actual systems can also combine the two: one is responsible for drafting, the other is responsible for determining whether it should be transferred to manual labor, and finally the program executes clear rules.

Perhaps what really deserves attention is how the software is written. In the past, programmers had to force many edge situations into if； Later, they tried to let the chat model handle the entire process. Jev demonstrates a middle ground: **Let the model answer small, well-defined questions, leaving actions, permissions, and safeguards in the code. Whether it can become a general practice depends on accuracy, how probability performs in real business, long-term prices, and whether developers can break down complex problems just right.

If you want to judge whether Jev is useful, you don't need to ask first whether it is "the next ChatGPT". Take out a judgment in your software that is repeated thousands of times a day, requires some comprehension, but has a limited range of answers: Who should the complaint be distributed to? Is the invoice missing any materials? Which work orders should be reviewed by someone first? Compare accuracy, latency, total cost, and misjudgment costs using a batch of old cases with artificial conclusions. The answer will be closer to what you really need to know than any "two hundred times faster" sentence.

Finally, in layman's terms

Jev can be understood as a very fast AI sorter or referee: you give it a situation and a few limited options, and it doesn't write a long answer. It only tells you "which one to choose, how many points to give, and whether it is true or not," and then the software continues to execute according to the results. Traditional generative AI is mainly responsible for writing out text, while Jev is mainly responsible for providing small judgments that the software can be used directly. The former is better suited to interpreting, creating, and dealing with open-ended questions, while the latter is better suited to hiding in the background and dealing with decisions with a lot of repetition and a clear range of answers.

Written on September 20, 2026. The figures regarding price, speed, and performance in this article are all from publicly available materials from TypeSafe at the time; Customer service emails and forms are illustrative examples of the principles and are not independent tests.