Jev: the fast, affordable AI model that decides

Until now, for an AI to make a decision within a process, a language model had to be used: it was given the question, it reasoned, it answered with a sentence, and then a piece of code had to read that sentence and work out what it had decided. It works, but it is slow, expensive, and fragile.

Jev, by TypeSafe AI, works differently: it decides, it does not write. It receives the situation and the possible answers, and returns the chosen one with its confidence level, in a format that the next program can process directly.

A faster, more affordable AI model that decides instead of writing

A language model thinks out loud, word by word. That is what is needed to write a report or explain a line of reasoning, and that is why it is slow and costly. But many of a company’s decisions do not need reasoning: is this email a complaint or an order? Does this contact fit what we are looking for? Is this sensor value normal? A person answers them in half a second.

A model like Jev makes that kind of decision directly, without going through all the reasoning layers of a language model. It is what is called a “System 1” model. For a company, this translates into three advantages:

It is faster and cheaper. Enough to use it hundreds of times in a row at a manageable cost, which is what a high-volume process requires.
The answer does not need interpreting. It arrives as a specific option, not as a “Yes, of course, it looks urgent” that the next program cannot read. That error, common in AI automations, disappears.
The confidence comes with the answer. This makes it possible to design the right flow: above a certain confidence level, the system decides on its own; below it, a person reviews it.

Jev does not replace language models: it complements them

For writing, summarizing, or reasoning, language models are still the tool. What a model that only decides brings is that it opens up use cases that until now could not be handled in the same way: reviewing thousands of items a day, one by one, with a language model was too slow and too expensive to be worthwhile.

That is why the usual approach is not to choose one of the two, but to work in layers: the model that decides filters and classifies everything that comes in, and the language model only works on what has passed the filter. Each one does what it does best, and resources are spent where they add value.

How Jev benefits automations

In an AI automation, the workflow is decided in advance (if A happens, then B) and the AI handles specific steps. When a step is a decision, a model like this fits naturally:

Classifying and routing what comes in. Emails, tickets, incidents, or orders: which department they go to and with what priority.
Validating data before passing it to another program. Making sure that what goes into the ERP or the invoicing system is valid, not just that the field is filled in.
Scoring the contacts that come in from the website, so that the sales team starts with the ones that fit.
Filtering large volumes of calls for proposals, news, résumés, or documents before a language model reads anything.

Jev in AI agents

An AI agent decides its own path, and every step is a decision. With a model that only decides, the agent:

Chooses the next step or the tool without going through a language model every time.
Knows when to ask for approval. What is clear goes ahead, and what is doubtful is reviewed by a person.
Has guardrails. Its actions are reviewed before they are executed, and risky ones are stopped before they happen.

Jev with machine data

In a plant, data arrives every few seconds and the decision has to arrive just as fast: whether a value is normal or whether a stoppage warrants an alert. It is a clear application of AI in manufacturing: an assembly line does not need an AI that generates text, but a fast intelligence that reviews and decides.

Real use case: filtering public tenders in layers with Jev

To see how the pieces fit together, consider a real use case applied to one of our own tools, an intelligent tender search engine:

An agent searches. At regular intervals, it reviews the calls for proposals and tenders published on the internet.
Jev decides whether it fits. It compares each tender with the parameters of the company that wants to bid and returns whether it fits and by what percentage. The ones that do not fit are discarded at that step and are not recorded in the tool.
An automation downloads the specifications of the tenders that have passed the filter.
A commercial language model analyzes them. It reads the specifications, estimates how difficult it is to bid as a percentage, and writes a summary.
And the person in charge of tenders decides, with the summary and the two percentages in front of them, whether it is worth taking part.

Jev processes and filters the published data; the language model, which is the expensive one, only reads what has passed the first filter. That is why processing more sources does not multiply the cost in the same proportion: the initial filter is the cheap part.

The same pattern works for any question of the type how similar is this to what I am looking for?: suppliers against a set of requirements, new data against the data already stored, or incidents against the ones already resolved.

When a model that only decides does not fit

When something has to be written: drafting an email, summarizing meeting minutes, holding a conversation, or explaining a line of reasoning. That work is still for a language model.

Nor when the decision is a one-off and important. A model like this pays off at volume, across thousands of small decisions; for a decision made once a year, speed is not the bottleneck.

Where to integrate Jev: custom software, mobile applications, and data

Jev is not a chat tool: it is integrated into other programs through its API. The application sends the data and the possible options, and receives the chosen option with its confidence level in less than a second. It supports three types of question: choosing between several options, scoring against a set of criteria, and estimating whether a statement is true.

In custom software

Business applications make repetitive decisions that today depend on a person or on a fixed rule: assigning a task, prioritizing an incident, or flagging an order for review. In custom software, Jev can make them at the moment the data is recorded. Decisions with low confidence are left pending review.

Example: in an incident management application, each incident is assigned to a technician and a priority when it is created.

In mobile applications

In an app, the decision has to arrive while the user waits: Jev answers in less than a second, and a language model takes several. In mobile applications, the call is made from the application server, not from the phone, so as not to expose the access key or send more data than necessary.

Example: in a job report app, the technician writes a note and the app suggests the type of job (breakdown, maintenance, or quote) and the priority.

In document and product classification

Jev assigns each item to one of the categories defined by the company: document types, product families, or reasons for contact. It is applied in a document management system or in a product catalog.

Example: based on the text of each document uploaded to the document management system, Jev indicates whether it is an invoice, a contract, a delivery note, or a quote, and the application suggests the folder where it should be filed.

In data cleaning and normalization

In a migration or a data quality audit, free-text fields become closed lists. Jev assigns each manually entered value to an option on the list.

Example: in a CRM migration, the “sector” field contains hundreds of variants, such as “hospitality”, “food service”, or “bar-restaurant”. Jev assigns each one to a sector on the new system’s list; the ones without a clear match are left for review.

In detecting invalid data

Format validations check that a field looks like a phone number or an address, but not that its content makes sense. For that, Jev evaluates statements such as “this description corresponds to this product” or “this text is an address”, and returns a probability.

Example: in a supplier import, before the data goes into the ERP, the records that have the company name in the contact person field or a description that does not match the category are flagged.

What needs to be defined before integrating Jev

The questions. Jev gives better results with specific, separate questions than with one complex question, so each decision is broken down into several. The questions are evaluated in parallel, so adding more hardly changes the response time.
The possible answers, closed and known in advance.
The confidence threshold above which the system acts without review.
The data that is sent, because Jev is an external service.

Frequently asked questions about Jev

Does Jev replace ChatGPT?

No. ChatGPT is a language model: it writes, summarizes, and converses. Jev does not generate text: it returns a decision and its confidence level. In many processes they are combined, as in the tender use case.

Is Jev smarter than ChatGPT or Claude?

It is not a direct comparison: ChatGPT and Claude write and reason, and Jev only decides. In decision tasks, the benchmarks published by the vendor place it at the level of mid-range language models and a few points below the most powerful ones. An independent study by the University of Bonn places it above medium-sized open models in most tests, although it performs worse with very similar categories and in less common languages. It is chosen for its speed and cost, not for being the most capable.

Does it work for AI agents?

Yes. In an agent, Jev can choose the next step or the tool, decide whether an action needs approval, and stop risky actions before they are executed.

How much does it cost to use Jev?

Much less than a language model for the same work. We have not used it at that volume ourselves, but in the independent study by the University of Bonn, about 346,000 queries cost less than €9. In a project, the main cost lies in the integration with the programs already in use.

Does the data leave the company?

Yes. Jev is a TypeSafe AI service, and the information sent to it leaves the company. Which data is sent is decided when the integration is designed. When no data can leave, private AI is used, with models on private servers.

Do you need automations already in place to use it?

No, but the decision has to be part of a process: an application or an automation that, with the answer, routes an email, creates a record, or sends an alert.