The model that refuses to talk

Here is a question a piece of software somewhere has to answer a few thousand times a day: is this email a complaint?

It is not a hard question. A human reads the message and knows, in about a second, without being able to say quite how. For the last three years or so, the standard way to get software to answer it has been to send the email to a large language model — the kind of thing that sits behind ChatGPT — and ask it, in writing, to reply with the word “yes” or the word “no”.

That works. It works well enough that it became the default almost everywhere, and I’ve built plenty of it myself. But look at what is actually happening. You have a model trained to compose arguments, write code, explain the Peace of Westphalia and hold a conversation in four languages, and you are asking it to say yes. It deliberates. It writes a sentence. Something on your end reads that sentence back and tries to work out which answer it contains.

It is hiring a lawyer every time you need someone to answer yes or no. You get a correct answer, eventually, beautifully composed, and you are billed for the composition.

The fast half and the slow half

The most useful frame here is one most readers already own, from Daniel Kahneman’s Thinking, Fast and Slow. He described two ways of thinking that run in all of us. One is fast, automatic, effortless — you look at a face and know it’s angry, you glance at an email and know it’s junk. You don’t reason your way there. The other is slow and deliberate: the one you use for a tax return, or an argument you intend to win.

You need both, and you’d be exhausted within an hour if the slow one had to handle everything.

That is roughly what we’ve been doing to software since 2023. We built an extraordinary slow thinker and then handed it every reflex in the building — every routing decision, every “is this relevant”, every “which of these forty tickets matters”. The machine deliberates about whether an email is spam, then writes you a little essay about its conclusion.

On 15 September, a company called TypeSafe AI released a model built to be only the fast half. It’s named Jev, after the Victorian economist William Stanley Jevons, and I’ll come back to why that name is a small joke with a point in it. Its founder, Diogo Almeida, is a former OpenAI researcher who worked on the training method that made ChatGPT possible — which is worth knowing, because this is someone leaving the slow thinker behind on purpose.

Jev does not write. It cannot write. You hand it some text and a question of one of three shapes — pick one of these options, score this on this scale, is this statement true — and it hands back an answer of exactly that shape, with a probability attached. No prose, no explanation, nothing to parse. TypeSafe calls this category a System One model, which is a direct enough borrowing from Kahneman that nobody could accuse them of hiding the reference.

The part the launch coverage skipped

It would be tidy to say that large language models ate the humble classifier in 2023, and that Jev is now handing the job back. Tidy, and wrong in a way worth correcting, because it’s the version most people have absorbed.

Smaller, purpose-built classification models never went anywhere. They are still running, in enormous volume, inside spam filters and content moderation and every ranking system you touch daily. What changed in 2023 is that new projects stopped building them. Training one required labelled examples — thousands of emails someone had sorted by hand — and a person who knew how to do the training. A large language model needed neither. You wrote your question in English and got an answer that afternoon.

Convenience beat economics, as it usually does. The result is that we’ve spent three years paying essay prices for reflex work, because the reflex version required a project and the essay version required a sentence.

The other incumbent deserves naming, because any engineer reading this will have thought of it already: embeddings. They’re the cheap workhorse for “find me things similar to this”, and they’re genuinely good at it. But they measure resemblance, not judgment, and the difference shows up fast. “I do not want a refund” and “I want a refund” look nearly identical to a system that measures resemblance — same words, same subject, opposite meaning. Negation defeats them. So does any question with an if in it.

So what is actually new? Not any single ingredient — a fair-minded skeptic would call this a well-productised assembly of things that already existed in research, and they’d be partly right. Three things are assembled here that hadn’t been before.

The first is that the model doesn’t write its answer out word by word. Everything you ask is evaluated in one parallel pass, which is why asking it twelve questions about a document costs roughly what asking one does.

The second is calibration, and it’s the one I’d underline. TypeSafe trained the model with the explicit goal that its confidence numbers mean something: across many comparable cases, the answers it marks 0.9 should be right about ninety percent of the time. That sounds like a technicality and isn’t. It’s what makes “if the model isn’t sure, send it to a human” a real instruction rather than a hopeful one. Old classifiers were notoriously bad at this, and a large language model announcing that it’s “highly confident” is close to meaningless — it has learned what confident prose sounds like.

The third is simply that the typed decision is the product. Not a chat box you constrain afterwards with careful instructions and a parser. A thing whose entire job is to return one of the answers you declared.

None of this is speculative on my part, and I haven’t tested any of it, so take every number here as the manufacturer’s. TypeSafe publishes response times in the range of 70 to 500 milliseconds and a price of about four cents per million words of input, with the output free — which it can afford to be, since the output is a number. Their own launch demos are charming and slightly beside the point: the model plays Doom by making around ten decisions a second, which TypeSafe cheerfully notes a conventional bot does better.

Jevons, on purpose

Now the name.

William Stanley Jevons noticed in 1865 that as steam engines became more efficient, Britain burned more coal, not less. Cheaper coal-power meant more uses for it, and the new uses swamped the savings. The pattern has held for nearly everything since: make something dramatically cheaper and total consumption goes up.

Naming a decision model after him is either a good joke or a statement of intent, and it reads as both. The thing to understand is that cheap decisions don’t reduce how much we use expensive models. They relocate it.

Picture five hundred documents and a question worth asking about them. Today nobody asks, because five hundred careful readings is a budget nobody has. With a decision model, all five hundred get triaged in a few seconds, three come out the other side, and the expensive model reads those three properly. You did not use less of the frontier model. You pointed it at the right thing.

Multiply that across every form field, every log line, every routing point that was never worth a model call before, and the volume of machine decisions rises steeply while prose generation gets rationed to the cases that actually need words. More AI, in other words, but better aimed.

This isn’t a new conviction on my part — I’ve been building this way for a while, and my sovereign deployments run on exactly this division of labour: small models doing fast semantic decisions inside the compliance boundary, the big model called only when something genuinely has to be reasoned about or written. What’s changed is that the small half now comes as a product instead of a project. In the Artificielle episode about autocomplete I described how a text-prediction trick ended up eating the entire field. This is a piece of the field being handed back.

Who draws the doors

There’s a sentence in TypeSafe’s material worth sitting with: the model can’t hallucinate. It’s defensible, narrowly. If you declared three possible answers, you will get one of those three. The model cannot invent a fourth, cannot invent a citation, cannot wander off. The class of failure where the machine confidently fabricates something that does not exist is genuinely closed.

But notice what that guarantees and what it doesn’t. It guarantees the shape of the answer, not its correctness. The model can still pick the wrong door — confidently, in eighty milliseconds, for eleven thousand customers in a row. And a wrong-but-valid answer is much quieter than a crash. When a system fabricates a court case, someone notices. When it routes a refund request into the complaints queue because the sentence was ambiguous, nothing breaks; the number just comes out slightly wrong at the end of the quarter, and no one can say why.

I’ve made this distinction before in a different context, when I spent six weeks watching tested code be wrong in five places. Verified is not validated. The tests confirmed the code did what it said. Only someone who knew the history could say whether what it said was right.

Which brings me to the thing I actually find interesting about this launch, and it isn’t the speed.

With a decision model, a human writes the question and draws the doors. Someone has to decide that there are three categories and not five, that “urgent” means this and not that, that the threshold for escalating to a person sits at 0.8. The machine’s entire contribution is choosing between options a person defined. That’s a smaller job than the one we’ve been giving these systems, and it’s a much more honest one — the judgment is visible, written down, and belongs to somebody.

Constrained is not the same as infallible. But a system that can only be wrong within a set of answers you chose is a system whose failures you can find, count, and argue about. That’s not a lesser kind of AI. It’s the kind you can be held responsible for.