This week was one of those that leaves your news reader glowing red. Grok 4.7 came out on September 21 and, the next day, almost at once, we got Claude Opus 5.5, GPT-6 Sol, GPT-6 Luna and two new models from Xiaomi (here’s the full timeline). Bigger models, more capable, more expensive to train. That’s the story everyone will be talking about, and fair enough.
But the one that made me stop came a week earlier, from a company you’ve probably never heard of. On September 15, TypeSafe AI released Jev, a model that doesn’t write a single word. It was introduced by its founder, Diogo Almeida, who worked at OpenAI on the methods that ended up behind ChatGPT, with a confession I find about as honest as anything I’ve read this year. In the launch post he says that for a while he thought chat models might lead us to AGI, and that over the years it became obvious to him that something really big was missing.
When one of the people who helped build the oracle tells you the oracle wasn’t the way, it’s worth stopping to listen. And listening to him, my mind went to two books that have nothing to do with each other: one about psychology and one about machine learning. That’s what this piece is about.
A model that doesn’t write
Jev isn’t a chatbot, and it’s worth understanding exactly what it does, because the whole argument hangs on it.
You give it two things. The first is a state: a support ticket, an email, the JSON describing what your application looks like right now. The second is a question whose possible answers you’ve already defined. It gives you back a probability for each answer. That’s it. There are three kinds of question: pick one option from a closed list, place something on an ordered scale, or answer yes or no with a probability.
Why does taking the text away matter so much? Because today, when you put an LLM inside a program, you ask for the answer as text (or as JSON written as text), you parse it, validate it, and cross your fingers that it doesn’t invent a field or break the format. Jev can’t step outside the schema, because it doesn’t generate anything: the answer can only be one of the ones you defined upfront. TypeSafe describes it as a kind of smart if statement: a fuzzy decision that slots into ordinary code, right where a hand-written rule falls short and an LLM call is too slow or too expensive.
There’s another word that keeps coming up in the launch: calibrated. A calibrated probability is one that, when it says 80%, is right roughly eight times out of ten. It sounds like a technical footnote and it’s exactly the opposite. As the post itself points out, if a system gets things right 95% of the time but never tells you when it’s in the other 5%, you can’t automate anything with it. Well-measured confidence is what lets you decide what runs on its own and what needs a person.
The numbers, always according to TypeSafe: responses in 70–500 milliseconds versus the 3–329 seconds frontier models take, between 40 and 200 times faster for queries shaped like this, and $0.042 per million input tokens with output for free. Their homepage goes as far as 193.6x faster and 444.6x cheaper (that’s where the “400x” doing the rounds comes from), but the post itself warns those figures sit at the high end of what you’ll see in production. I’ll take the range, not the headline.
Thinking, fast and slow
TypeSafe calls this family System One Models, and the name isn’t an accident: as they explain themselves, it comes from Thinking, Fast and Slow, by Daniel Kahneman.
If you haven’t read it, the idea fits in one example. When you see an angry face, you know the person is angry without thinking about it: you don’t decide to know, you just know. That’s System 1: fast, automatic, cheap. If I ask you to multiply 17 by 24, on the other hand, you have to stop, hold numbers in your head and work it out step by step. That’s System 2: slow, deliberate, costly. Kahneman spent a good part of his career explaining that much of what we do and decide is handled by the first, and that the second is an expensive resource we switch on only when we must.
LLMs that reason step by step, the ones that think for seconds or minutes before answering, are textbook System 2. And TypeSafe’s thesis, which I largely share, is that most decisions made inside software are System 1 shaped: what is this ticket about?, is it urgent?, can a script handle this or does a person need to see it? We’ve spent three years renting a very expensive System 2 to answer System 1 questions.
One nuance I don’t want to skip: in Kahneman, System 1 is also the one that gets things wrong most, the home of biases and shortcuts. TypeSafe argues that an artificial, calibrated System 1 can be more reliable than the alternatives. It’s an interesting bet, but for now that’s what it is: a bet.
Six clones in two days
What happened after the launch is almost more interesting than Jev itself. Demand was such that TypeSafe briefly couldn’t serve its API, and meanwhile the community started replicating it in the open. Latent Space counted six clones in two days: some built on ModernBERT, others adapting Qwen models, and even one repurposing a diffusion model. I’ll focus on two.
The first is Kev, by Jared Palmer. Its first version, Kev-0.5B, is a LoRA adapter with a small decision head on top of Qwen2.5-0.5B, and it was trained on September 17 on an Apple laptop with 32 GB in about an hour and three quarters. One afternoon. Within days it was superseded by Kev-0.8B, Kev-4B and Kev-9B, now on Qwen3.5 bases, with a recipe found after around 110 controlled trials. And it speaks the same language as TypeSafe’s API: you can write your code against Jev today and point it at your own server tomorrow.
The second is Laya, by Convai Innovations, released on September 18 under Apache 2.0. It’s built on ModernBERT-large, with 421 million parameters (plus a 322-million multilingual variant), and it answers in about 33 milliseconds on a T4 GPU, which is hardly cutting-edge hardware. In case BERT sounds odd here: it’s a family of models that don’t generate text word by word, but read the whole text at once and produce a representation of its meaning. Exactly what you need when you want to classify rather than write. That’s why it’s so fast.
And here comes what, for me, is the most important line of the whole week. Laya’s model card is brutally honest: out of the box, on typed decisions, it gets 36% right, barely above chance and below just always answering the most common option; fine-tuned on that same task’s training data, it climbs to 77%. Its authors sum it up by saying Laya is a fast base to specialise, not a decision engine that works out of the box.
That is exactly what I’ve been expecting for a while. Small models, cheap to train, not worth much in general and worth a great deal once tuned for your case. A laptop, an afternoon and your data. In this model, hyper-personalisation isn’t a luxury add-on: it’s the design.
The book I’ve been chewing on for years
In 2015, Pedro Domingos published The Master Algorithm, one of those books that changed how I look at the field. Domingos split machine learning into five “tribes”, five schools with their own idea of what learning is and their own star algorithm:
- The symbolists, who see learning as logic: deducing general rules from examples (their tool, inverse deduction).
- The connectionists, who mimic how connections between neurons adjust (backpropagation, the engine of every neural network).
- The evolutionaries, who search for solutions by generating variants and keeping what works (genetic programming).
- The Bayesians, for whom learning means updating degrees of belief as evidence arrives (probabilistic inference).
- The analogizers, who reason by similarity: if this looks like that, it can probably be solved the same way (support vector machines and, before them, nearest neighbour).
And he made an explicit bet: that all knowledge, past, present and future, could be derived from data by a single, universal learning algorithm. But careful, because this is easy to misread. Domingos didn’t expect one tribe to beat the others. What he argued is that we needed one algorithm combining the best of all five, and his own candidate, Markov logic networks, was an attempt to marry the symbolists’ logic with the Bayesians’ probability. The master algorithm was a fusion, not a victory.
Eleven years later, we don’t have that algorithm. But I get the feeling the five tribes are still here, very much alive, just wearing product names instead of school names.
The five tribes, eleven years later
The connectionists won the ground floor. Everything released this week, from GPT-6 to Grok 4.7, is backpropagation scaled as far as money goes. But Jev, Kev and Laya are neural networks inside too. The connectionist tribe didn’t win a region of the map: it won the substrate everything else is built on.
The Bayesians come back as a requirement. Jev doesn’t do Bayesian inference in the strict sense, but its training is designed so that the only way to maximise reward is to report the honest probability (Laya’s card, which uses the same approach, explains it the same way). That’s the good old Bayesian spirit: don’t give me a verdict, give me a degree of belief I can use.
The symbolists live in the contract. Look at the company’s name: TypeSafe, type safety. Before the model sees anything, a person has declared which answers exist, what shape they take and what each one means. That’s pure symbolic knowledge. The same goes for ontologies, knowledge graphs and the policies that say what an agent may and may not do. Nobody trains that with gradients; somebody writes it.
The analogizers live in memory. Every time a system retrieves the documents most similar to a question (what we call RAG) or searches a vector database, it’s using this tribe’s oldest trick: nearest neighbour. This looks like something I’ve already solved, so I’ll start there. Just at the scale of millions.
The evolutionaries work in the workshop. There’s no genetic programming here in the literal sense, but the pattern is crystal clear: many variants at once, trials and discards. Kev reached its current recipe after around 110 controlled trials, and it was developed with the help of a coding agent. The whole ecosystem did the same thing at another scale: six different architectures competing for the same slot in two days. We’ll see which ones are still around in a year.
The fusion happened, just not where Domingos was looking
This is where the map gets interesting, and where I want to sharpen the analogy a bit so it doesn’t end up too neat.
Domingos was looking for fusion inside the algorithm: a single piece of mathematics that learns the way all five tribes learn at once. What happened is something else. Down below, in the substrate, there has been unification: almost everything is a neural network trained by gradient descent. But up above, in what each piece does inside a system, diversity has come back hard. The tribes are no longer competing methods; they’re roles being handed out.
Jev itself is the best example: a connectionist body, a symbolist contract and a Bayesian output. Three tribes in a single product. The fusion exists, but it doesn’t happen in the equation. It happens at the interface.
And there’s one piece left that doesn’t belong to any tribe: the one that decides who plays when.
The conductor who doesn’t play an instrument
Think about how something as ordinary as an incident arriving by email gets handled today. The trivial stuff is solved by plain old code, no model at all. A System 1 model decides in milliseconds what it’s about, whether it’s urgent and whether there’s too much uncertainty to carry on without a person. Only the hard minority reaches System 2, the big LLM that reasons, plans and writes. It’s the cascade pattern already being proposed around Jev: code does what it can, the fast model routes, and the big model takes the hard cases. And around all of it, a graph holding the house rules (symbolists) and a memory of similar cases (analogizers).
None of those instruments is the master algorithm. The closest thing is the conductor: the layer that decides which instrument comes in, when, and from which score. It’s what a good part of the industry is starting to build as agentic operating systems: a layer that can launch agents against concrete use cases, take them from idea to production, and choose, at every step, which piece handles it. For me, that’s where the real core of the coming years lies. Not in having the biggest model, but in knowing how to conduct.
That said, there’s an important difference from what Domingos imagined, and I don’t want to gloss over it. His master algorithm was, above all, an algorithm that learns. Today’s conductor, on the other hand, barely learns at all: it’s hand-written logic plus an LLM improvising on a set of instructions. The day the conductor learns to compose the orchestra by itself, from experience rather than from a prompt, we’ll be closer to what Domingos dreamed of than with any new frontier model. That, for me, is the interesting question of the next decade.
Why I think vibe coding is a phase
All of this brings me to something I’ve been chewing on for months. Vibe coding, describing what you want to an agent and getting a whole application back, is the purest form of the oracle myth: one big mind you ask for everything. It works, and for prototyping it’s wonderful. But generating code with agents is already everyday stuff. Coding benchmarks and agent-built programs are no longer the problem that keeps anyone up at night. And when something becomes everyday, it stops being where the game is played: it becomes an ingredient.
What I see coming is hyper-personalisation. Companies building their own applications for their own needs, on top of small models tuned for concrete cases, trained without outlandish compute budgets and backed by fast decision layers like the ones we just saw. In that world, the question stops being “what’s the best model?” and becomes “how do I compose my orchestra?”: which decisions are System 1, which deserve a System 2, what knowledge I need to declare and what memory I want to keep.
I don’t think vibe coding will disappear because it fails. I think it will disappear as a category because it will dissolve into the conductor, the same way nobody today says they “use a compiler” as if it were a separate activity.
The single oracle was the wrong question
The race to scale and the pursuit of AGI start from a very specific picture: one mind, big enough, that solves everything. And the funny thing is that the people who know that picture best from the inside are starting to bet on something else. Almeida left chat to build decisions. Yann LeCun left Meta to found AMI Labs, which raised $1.03 billion to build world models with his JEPA architecture instead of language models. The frontier isn’t concentrating: it’s spreading out. Huge models to reason, tiny models to decide, world models to understand physics.
And maybe that shouldn’t surprise us so much. Kahneman explained fifteen years ago that not even our own heads work as a single system: there’s a fast mode and a slow one, each good at its own thing, sharing the work. Domingos, for his part, needed five tribes to describe what learning means. I’m not quite sure why we expected machine intelligence to be one single thing.
If intelligence was never one thing, but several different ways of solving problems plus something that decides which one to use, then AGI understood as a single oracle isn’t a distant destination. It’s a badly framed question. The good question is a different one: how we compose, coordinate and trust many different mechanisms at once.
The fine print
- Jev’s figures are the ones TypeSafe publishes, not an independent measurement. Their workflow evals were designed by their own team and use the average of GPT-6 Astra and Fable 5.1 as the reference; they say so themselves in the post. And the 193.6x / 444.6x on their homepage is, by their own admission, the high end.
- Kev and Laya are days old. They’re an early signal, not settled technology, and untuned Laya does worse than always answering the most common option.
- The five-tribes map is mine, not Domingos’s, and it’s a map of functions, not mechanisms: underneath, almost everything is a neural network. A purist Bayesian would rightly say that calibrating isn’t inferring.
- Domingos didn’t write about Jev, agents or 2026. What I’m doing here is testing his framework against one real week, not claiming a prophecy.
- In Kahneman, System 1 is the one that gets it wrong most often. That an artificial System 1 can be more reliable is TypeSafe’s bet, not a fact.
The verdict
The master algorithm, no. The orchestra, yes. And the score, who decides what, when and with which instrument, is where I think the real work of the coming years lies.
Ideas over code; evidence over hype.
Leave a Reply