Jev: the AI that makes decisions instead of conversation

We've become used to judging AI by the quality of its answers. Does it write well? Can it code? Can it summarise a 180-page PDF without making half of it up?

Jev approaches the problem from the other direction. It doesn't write anything or produce a polished paragraph. It looks at a situation and answers a closed question: which team should handle this request? Is this a qualified lead? Is this message urgent?

That may sound less impressive than a chatbot writing a business plan. In practice, it could be much more useful in an automation.

Jev isn't a miniature chatbot

TypeSafe describes Jev as its first System One Model. The name comes from the familiar "system 1": fast, intuitive thinking that makes a decision without launching into a fifteen-minute internal essay.

Jev understands text, JSON objects and lists. But instead of generating a response word by word like ChatGPT or Claude, it returns a structured decision with probabilities.

You provide two things:

• a state, meaning the information to analyse;
• one or more questions, with the permitted answers.

Its answers take three forms:

• Choice selects one option from several, for example sales, support or spam ;
• Score places the situation on an ordered scale, for example from "routine" to "urgent";
• Noul estimates the probability of yes or no, for example "Is this contact a qualified lead?".

The name Noul is a little unusual. Just remember that the answer isn't text: it's a probability your software can use directly.

Why businesses might find it useful

Take an e-commerce contact form. The same inbox receives a quote request, a delivery problem, a supplier proposal and a completely irrelevant message.

With a standard LLM, you usually ask it to return JSON. That works… until it adds an explanation, changes a field name or enthusiastically invents a category.

With Jev, the possible answers are defined in advance. The model can't create a category called "slightly annoyed but friendly customer". It has to choose within the given framework.

I tested this exact use case. From the form's content, Jev had to choose the right department, estimate priority and assess whether the contact looked like a real sales opportunity. Responses arrived in a few dozen milliseconds, in a format an automation could use directly.

You can then write simple rules:

• if route = support and priority exceeds a threshold, alert customer support immediately;
• if route = sales and the qualification probability exceeds 80%, create an opportunity in the CRM;
• if confidence is low, don't automate anything: pass it to a person.

That's where Jev becomes interesting: it doesn't replace the whole workflow. It provides the small decision-making step between "something has happened" and "what action should we trigger?".

Fast, and almost ridiculously inexpensive

At the time of writing, Jev 1.13 accepts up to 32,000 tokens. Its advertised price is $0.042 per million input tokens, with no charge for output tokens.

In other words, a 600-token form costs around $0.000025 to analyse. Even including the surrounding automation costs, the amounts remain tiny for sorting messages, qualifying leads or checking large volumes.

The model is available directly from TypeSafe and through OpenRouter. That's useful if you already access several models through one API: an LLM to write, Jev to decide and conventional code to apply the rules.

That division of work seems healthier than asking one large model to understand, decide, write and execute everything. You can hammer in a screw, but it's still a strange idea.

Good use cases… and bad ones

Jev is designed for repetitive decisions with options known in advance:

• routing emails or tickets to the right team;
• classifying incoming requests;
• assessing urgency, risk or buying intent;
• filtering an AI agent's actions before execution;
• detecting ambiguous cases that need a human.

Don't ask it to write the customer reply, explain its reasoning or solve a complex strategic problem. That's not its job.

You also shouldn't confuse constrained output and guaranteed truth. Jev won't break your JSON, but it can make a wrong decision. TypeSafe is clear about this: probabilities are calibrated across groups of predictions, not guaranteed for every individual case.

The right approach is to set thresholds. High-confidence decisions can proceed automatically. Others go through human review or a model capable of deeper reasoning.

The real change: stop using an LLM for everything

Jev won't replace ChatGPT, Claude or Gemini. It serves a different purpose.

An LLM is excellent at producing, rephrasing, explaining and exploring. Jev is designed to choose quickly among predefined answers. Traditional code remains unbeatable for checking an exact rule, calculating an amount or triggering a deterministic action.

The strongest setup combines all three: Jev decides, the LLM writes, the code executes.

That's also a good way to approach amarketing automation project: start with one frequent decision, measure errors, adjust thresholds, then expand. No need to build an autonomous agent running your company by Friday evening.

Jev is still very new. We'll need perspective, independent tests and, above all, trials with your own data. But the idea is excellent: not every AI task needs a talkative, expensive model.

Sometimes you just want a quick decision, an honest probability and JSON that doesn't go on holiday.

Do you have a stream of requests, tickets or leads to qualify? We can work out where this decision-making component would fit — and, just as importantly, where it wouldn't.

Sources: TypeSafe — System One, OpenRouter — Jev 1.13

Translated from the original French article. Publication dates, examples and figures refer to that original version.