# An AI that chooses instead of writing: from 3 seconds to half a second with Jev

> I added Jev, a model that classifies in half a second, in front of an OpenAI model: it handled 33% to 41% of the cases on its own, cheaper and with no loss in accuracy.

Author: Ricardo Brossard (Systems engineer · AI and automation) · Published: 2026-10-02 · Topics: AI, Agents, Evaluation
URL: https://ricardobrossard.com/en/blog/an-ai-that-chooses-instead-of-writing/

A call ends between a voice agent and someone who asked about an apartment. Now the system has to decide how it went: no answer, asked to be called another day, doesn't want to be called again, or wrong number. That decision produces the CRM actions: reschedule, create a task, opt out. It's ticking a box from a closed list. And it's almost always done by asking a language model to read the whole conversation and write the answer, which takes seconds.

Using a model that writes to tick a box is like asking someone to write an essay just to check a box. That's why I added Jev, an AI model that doesn't write: it chooses. I like trying new things as they come out on real projects and measuring whether they really add something. This one did: it handled 33% to 41% of the cases on its own, in half a second instead of more than 3, cheaper and without losing a single correct answer.

## What Jev is

Jev is a classification model. You give it a situation and a closed list of options, and it returns which one applies and how confident it is, for example "opt-out: 97%". It doesn't write or explain, and it can't make up an option that isn't on the list. That's why it answers in about half a second and costs about USD 0.00004 per query.

I added it to a post-call orchestrator I built in Python with LangGraph, a tool for chaining the steps of an AI process. After each call, the orchestrator receives the event with the transcript, decides the label and emits the CRM actions. There, each model does what it does best:

> Figure: Each model on its own job: Jev picks fast when the answer comes from a list; the OpenAI model reads, extracts and handles what's uncertain.

- Jev (Pick from a closed list): answers in half a second; picks only among fixed options; says how confident it is
- OpenAI model (Read and understand): reads the whole conversation; extracts the data for the actions; handles the uncertain cases

## How I added it without losing reliability

Jev works as a layer in front of the OpenAI model. The rest of the system doesn't know it exists, and that's on purpose: if Jev fails or doesn't respond, everything continues as before. The rule is simple:

- **Jev decides on its own only when it's confident.** With 90% confidence or more and a label that doesn't need data from the conversation (an opt-out, a discarded contact, a wrong number), the actions go out directly.
- **In every other case, the OpenAI model is the fallback.** It reads the conversation, classifies and extracts whatever is needed, as always.
- **There's also a second-opinion mode,** in which Jev only steps in if the main model is unsure or doesn't respond.

> Figure: Jev handles the clear cases in half a second; everything else goes to the OpenAI model, which works as the fallback.

1. The call's event arrives (System). The telephony data and the transcript.
2. Jev picks the label and says how confident it is (AI model). In half a second, from a closed list.
3. With 90% confidence or more, it goes straight on (System). Only for labels that don't need data from the conversation.
4. Otherwise, the OpenAI model reads the conversation (AI model). The fallback: it also steps in if Jev fails or doesn't respond.
5. Builds the CRM actions (System). Reschedule, create tasks, reminders or opt-outs.

On the technical side: this part has 24 automated tests that run without network access. One runs the whole batch of cases with Jev and checks that the CRM actions come out identical to the ones without Jev.

## The comparison that looked like a rout

Before measuring for real there was a lesson. In the first test, with 8 conversations, Jev got all 8 right and a cheap language model got none. It looked like a blowout, so I looked at the answers one by one.

The model classified a request not to be called again as "not interested", which is reasonable if you don't know the rules. And it didn't know them: I had given Jev the definition of each category and not the other model. With the same definitions for both, a tie: 8 out of 8.

> Figure: The first comparison was measuring something else: the catalog's definitions weighed more than the model. With the same information, a tie.

Correct answers out of 8 conversations:
- Jev, with the definitions: 8/8
- Cheap model, without the definitions: 0/8
- Cheap model, with the same definitions: 8/8 (The fair comparison)

Rigging a measurement by accident is very easy. That's why, from then on, every measurement used the same definitions for both models.

## What the measurement showed

I ran the full system five times on each conversation, using the cost the provider reports.

In the normal cases, 105 events, Jev handled a third on its own: the OpenAI model was called 70 times instead of 105. Those cases took a median of 0.5 seconds, against 3.2 seconds without Jev. Accuracy was 105 out of 105 with and without Jev, and the total cost went down 12%.

In a batch of hard cases, with opt-outs stated at the end of the call or phrased ironically, there were 70 events. Jev handled 41% on its own, the cost went down 23% and accuracy was 69 against 68 without Jev. Every decision Jev made on its own was correct.

I also tested it without the other model, deciding everything: it got 20 out of 20 cases right, with a median of 0.39 seconds. I don't use it that way because some labels need data from the conversation, and that's what the OpenAI model is for.

> Figure: In the cases it handles on its own, Jev answers in half a second; the OpenAI model, reading the whole conversation, takes more than 3.

Response time per case, median:
- OpenAI model: 3.2 s
- Jev: 0.5 s (In the cases it handles on its own)

Each query to Jev costs about six times less than one to the OpenAI model I used. The final savings depend on how much the main model costs: with one of OpenAI's cheapest, what Jev costs is what it saves, and the gain is in the speed.

## When it's worth using

Classifying is one of the most common AI tasks in a business. A classifier like Jev pays off most in three situations:

1. **When someone is waiting.** Routing a WhatsApp message, deciding which area a call goes to or classifying a complaint as soon as it comes in. Going from 3 seconds to half a second shows in a conversation.
2. **When volume is high.** Thousands of queries, tickets or leads per day, where every cheaper query adds up.
3. **When the answer comes from a closed list.** If you also need to read data or write, the classifier handles the clear cases and the language model takes care of the rest.

And one condition for every case: compare it with the same definitions and the same cases as the model you already use, and always keep a fallback.

## Your takeaway

Not every AI task needs the biggest model. When the answer is a choice, a model that chooses does it in a fraction of the time and the cost. The key is in the design: let it decide on its own only when it's confident, keep the language model as the fallback, and let a fair measurement confirm that nothing is lost along the way.

If you want the AI in your business to answer faster without losing reliability, get in touch and we'll take a look.

## Frequently asked questions

### What is Jev?

Jev is an AI model that doesn't write text: it chooses. You give it a situation and a closed list of options, and it returns which one applies and how confident it is, for example "opt-out: 97%". That's why it answers in about half a second and can't make up an option that isn't on the list.

### What's the difference between a classification model and a language model?

A language model generates text word by word, so it can answer anything, even something outside the list. A classifier only picks among fixed options and adds a confidence percentage. To tick a box, the classifier is faster, cheaper and easier to control; to read and extract data, you still need the language model.

### How much faster is a classifier like Jev?

In my measurement, the cases Jev handled took a median of 0.5 seconds, against 3.2 seconds for the OpenAI model that reads the whole conversation. Tested on its own, without the other model, Jev got 20 out of 20 cases right with a median of 0.39 seconds.

### How much does it cost to classify with Jev?

About USD 0.00004 per query, roughly six times less than each query to the OpenAI model I used. Adding it lowered the total cost by 12% in the normal cases and 23% in the hard ones. The savings depend on the main model: with one of the cheapest, what Jev saves is what it costs, and the gain is in the speed.

### Do you lose accuracy by adding a fast classifier?

In my case, no. On 105 normal events the accuracy was 105 with and without Jev, and on 70 hard cases it was 68 without Jev and 69 with Jev. Every decision Jev made on its own was correct, because it only decides when it is 90% confident or more.

### What happens if the classifier gets it wrong or doesn't respond?

That's what the fallback is for. If Jev isn't sure, if the label needs data from the conversation or if it doesn't respond, the case goes to the OpenAI model, which handles it as always. There's also a second-opinion mode, in which Jev only steps in if the main model is unsure.

### When is a classifier like Jev worth using?

When the answer comes from a closed list and someone is waiting: routing a WhatsApp message, deciding which area a call goes to or prioritizing a lead as soon as it comes in. Also when volume is high, because each query costs less. If you need to read, extract data or write, the language model does the work.

### How do you compare two AI models fairly?

With the same instructions, the same definitions and the same cases for both, and by looking at the answers one by one before believing the result. In one of my tests, a model seemed to lose 0 to 8 because it didn't have the category definitions; with the same information it tied 8 to 8.

### What is LangGraph?

LangGraph is a Python tool for chaining the steps of an AI process as a graph: each step is a part of the work and the graph decides where to go next based on the result. It makes the flow explicit, testable step by step and open to new pieces, like a classifier, without rewriting the rest.

### How do you add a new model without breaking what already works?

By wrapping the piece that already exists, without the rest of the system knowing there's something new, and with a safe way out: if the new model fails, everything continues as before. I also add a test that runs every case with and without the new model and checks that the CRM actions come out identical.

## Contact

- WhatsApp: https://wa.me/5493442679907?text=Hi%20Ricardo%2C%20I%20saw%20your%20site%20and%20I'd%20like%20to%20ask%20you%20about%20a%20project.
- Email: info@ricardobrossard.com
- LinkedIn: https://www.linkedin.com/in/ricardo-brossard
- GitHub: https://github.com/ricardobing