Diogo Almeida worked on the method that made ChatGPT usable, the famous step where humans rate the model's answers to teach it how to behave. On September 15, he announced the release of his own model, Jev, at TypeSafe AI, his company that has just raised 40 million dollars. And he did something nobody expected from this field: his model can't write.

Not "it writes badly". It doesn't write at all. You give it a situation, it gives you a decision. Not a sentence, not a paragraph, no "of course, here's what I think": a checked box, chosen from a list you set yourself, with a confidence percentage attached to it.

You're going to tell me that's a regression. Let's be serious for two minutes: it may be the most interesting thing to come out this week in the field, and for a very simple reason that I'll try to make clear.

What Jev returns exactly

A classic language model works by speaking. You ask it to sort an invoice into the right category, it will write you a nice sentence to do it: "Based on the information provided, this invoice appears to fall under the office supplies category." Thirty words, two hundred milliseconds per word, to convey four words of information. It's a bit like asking a mechanic whether your tire is flat and getting a cover letter.

Jev doesn't do that. Its output is a set of typed values, meaning things whose type is known in advance: a number between 0 and 1, a category taken from a list, a true or a false. It accepts up to 255 possible answers in its list, and beyond a hundred, it breaks the decision down into two scoring steps so it doesn't get tangled up.

The founder sums it up with a phrase I find very well put: "a function call with cutting-edge intelligence". A loose input, an orderly output. Nothing else.

Why it goes two hundred times faster

A model that writes moves forward word by word. It can't start its second sentence before finishing the first, because each word it produces becomes an input for the next one. It's a chain, and a chain is only as fast as its slowest link.

A decision doesn't need to be built in order. TypeSafe calls this a parallel sampler: the model works on all the possibilities at once, in the same calculation pass, and brings back the scores together. There is no second word to wait for, so there is no waiting at all.

One counter taking files one by one, or thirty counters open at the same time

The announced figures follow this logic. Between 70 and 500 milliseconds of latency, compared with 3 to 329 seconds for the heaviest models on the market. The 329 seconds aren't an exaggeration: that's how long a large model takes to produce a long piece of reasoning, and it's a figure that TypeSafe compares with that of its competitors.

And the price story is downright brutal. One million input tokens costs 0.042 dollar at TypeSafe. For output, it's free: their page writes it in black and white, "too cheap to measure". In their own tests, they announce 193.6 times faster and 444.6 times cheaper than text models, and a peak of 200 times on the tasks that suit them.

The figures, and the trap that comes with them

The entry price for one million tokens, and the range the seller itself gives for text models

You have to read the fine print, and it comes from TypeSafe themselves: these 193.6 and 444.6 figures come from their own benchmarks, built by their team, and the reference they compare themselves with is an average of two models they chose. They write it without anyone asking them to, which is to their credit, but it's still a seller's comparison. Measurements carried out by outsiders tend to land between 5 and 25 times faster, which is already huge and has nothing more to do with a factor of 200.

Three other details to keep in mind, and I'd rather say them right away. There is no scientific paper behind any of this, no published reliability curve, even though the heart of the method is precisely a matter of well-calibrated confidence. No client is named, no sales figures are given, access is by waiting list. And when the founder was asked whether his model was basically just a sophisticated classifier, he replied “exactly”, before refusing to describe its architecture.

That isn't necessarily shady: a two-month-old company emerging from anonymity doesn't have much to show. But it means that today, you're buying a promise with a price tag, not a proven product.

What it can't do, and it needs to be said clearly

It's a model for which you choose the possible answers before asking the question. So if the right answer isn't on your list, it will choose the least bad one and give you a nice confidence percentage to go along with the mistake. You don't ask it for an essay, or a cooking recipe, or to summarize a document. It can't invent a value that doesn't exist in the schema, which makes hallucination in the strict sense impossible, but that doesn't stop it from picking the wrong box. Important nuance, because this is exactly what the company's communication leaves unclear.

In their own evaluations of real-world tasks, their table shows a 67.8% success rate. In front, 73.1% for Opus 5 and 74.1% for Sol. In other words, on general judgment, the big text models are still ahead. What Jev wins on isn't the quality of the answer, it's the price and the time it takes to get it.

So what does that change for you in practical terms?

Most of the things we make an AI do in a home don't require any writing. Does this photo contain a face or a landscape? Is this email an ad or a message from the school? Should the heating be turned on now? Yes, no, in that category. A complete sentence has never been useful in these cases, we paid for it because there was no other way.

Sorting family photos: the machine organizes them, nobody reads anything, and the bill is divided by twenty

The real effect is the price and speed at the scale of a home. A box that sorts the phone's photos overnight, a server that sorts emails before you open them, a subtitle program that decides for each bit of sound whether it's speech or music: all tasks where we were paying a literature engine to check boxes. If the advertised price holds over time, these functions become cheap enough to run constantly instead of being a setting you hesitate to turn on.

The deadline, on the other hand, isn't tomorrow morning. The product is in early access, on a waiting list, with no public client. And as for the price of $0.042, the company itself admits it can't prove that it isn't subsidized. It's the introductory price of a young company buying its users, not yet a market price. I know token bills well enough to know that a launch price says nothing about the one we'll pay in two years.

If you're a developer

That's where it really matters, because the product is sold to programs, not humans. You describe your output schema, you send the state of your system, you receive a decision that can be used directly, with no text analysis to do afterward.

POST /v1/decisions
{
  "schema": { "categorie": ["facture", "devis", "publicite", "autre"] },
  "input": "<le texte ou l'etat du systeme>"
}
# reponse : categorie = "devis" (0.94)

The gain isn't just the cost: it's not having to write code to parse a response in natural language anymore. No more “the model answered yes but in paragraph form, we need to extract the value”. The output is already data.

Two developer reservations, which I haven't seen addressed in the communication. A schema has to be designed, and a badly designed schema will give you perfectly calibrated errors with 94% confidence. And the published load figures are those of a service with restricted access: no latency guaranteed under heavy traffic, no availability commitment. For tinkering, no problem. For something that has to respond at night while everyone is asleep, we'll wait and see.

Last month, I explained in another article that the next Astra wouldn't answer any faster, but that it would work for longer. That was the general trend at the time: models that spend thirty seconds thinking to gain in quality. Here comes an old hand from the house going in exactly the opposite direction, accepting a loss in finesse for what it gains in speed. The two approaches don't exclude each other, they divide up the work: long reasoning for what deserves thought, immediate decisions for everything else.

There's one question I've been asking myself since I read their figures, and I don't have the answer: if half of what we get an AI to do never needed it to write, how much longer are we going to pay by the word for something that's sold by the decision?