Jev, Cactus Needle & Laya: Rise of Decision Models

There's a strange new trend happening in AI. For the last few years, whenever we wanted software to understand language, the answer was increasingly simple: Give it to an LLM. Need to classify a support ticket? LLM. Choose which tool an AI agent should call? LLM. Decide whether something is spam? LLM. Check whether an agent actually completed a task? Again... LLM. But there's a problem. Most of these tasks don't actually require the model to generate language. If I say: “My package was supposed to arrive Tuesday, and it still isn't here.” my application probably doesn't need a beautifully written paragraph explaining the situation. It may just need: “Delivery problem.” Or maybe a probability: “Delivery problem: 97 percent.” So why are we running a giant generative model, generating tokens one after another, just to arrive at a tiny decision? That's the idea behind a fascinating group of new AI models. And one of the models that suddenly brought a lot of attention to this idea is Jev. Jev was released by TypeSafe AI in September 2026 as what the company calls a System One Model. Instead of asking Jev to generate an answer, you give it some state and ask questions about that state. Those questions can take three forms. Choice: choose between several possibilities. Score: evaluate something on an ordered scale. And Noul: essentially, what is the probability that this statement is true? So imagine an AI agent has just attempted to book a flight. Instead of asking an LLM: “Analyze everything that happened and tell me whether the booking succeeded,” you could ask Jev: “Did the booking succeed?” And get back a probability that your software can immediately use. TypeSafe says Jev uses a new architecture and a training technique called Reinforcement Learning for Calibrated Decisions. The company also makes some very aggressive claims about speed and cost compared with frontier LLMs. Those claims still need broader independent validation. But Jev itself isn't really what I want to focus on. Because almost immediately, an interesting question appeared: Can we do this with open-source models? And that takes us to something much smaller. Cactus Needle attacks this problem from almost the opposite direction. Instead of asking: “How intelligent can we make a giant model?” Needle asks: How small can we make a model that is intelligent enough to perform useful actions? The current Needle 3 family ranges from roughly 29 million to 121 million parameters. Not billion. Million. And the actual downloadable models can be only a few tens of megabytes. Needle is designed for things like phones, wearables, robots, smart-home devices, cars and even microcontrollers. And it isn't trying to be ChatGPT. It deliberately gives up general conversational ability. Instead, it's optimized for things machines actually need to do: Choose tools. Fill tool arguments. Extract structured information. Classify things. Create embeddings. And control devices. Needle 3 also has an unusual architecture. Cactus calls it a Laddered Simple Attention Network. A large portion of the model's parameters live in something called an engram — essentially an n-gram memory that can retrieve learned patterns very cheaply. So while the largest Needle has 121 million parameters, Cactus says its active arithmetic is closer to a roughly 50-million-parameter model. It's also laddered. The model is trained so that different depths — from only a couple of layers all the way to twenty — can become deployable models. So the same architecture can be scaled depending on the device. And when Needle generates a tool call, a grammar derived from your tool schema constrains the output so that the resulting call is structurally valid. This is a very different philosophy from today's giant LLMs. You're not trying to build one enormous artificial brain that knows everything. You're building a tiny piece of intelligence that knows enough to make the decisions your software actually needs. But then another project asks an even more interesting question. Do we actually need a new architecture at all? Laya is an open-source project that looks remarkably similar to the basic Jev interface. You give it some state. You ask typed questions. And it gives you decisions without autoregressively generating a paragraph. It supports the same general concepts: choice, score and yes-or-no probability decisions. But underneath, Laya uses familiar encoder models. Its English model is based on ModernBERT-large, at around 421 million parameters. Its multilingual version uses mmBERT, at around 322 million parameters. And these models process the decision in a single forward pass. The Laya project reports around 33 milliseconds for a single question on an Nvidia T4, and around 7 milliseconds per question when batching ten questions. There's also a specially fine-tuned Laya Typed-Decisions checkpoint. On Laya's published benchmark of 2,000 decisions, that checkpoint reports 76.6 percent accuracy, compared with a published Jev result of 72.7 percent. But there's an important caveat. The generic Laya checkpoints perform substantially worse on that benchmark. The high score comes from a checkpoint specifically fine-tuned for those typed-decision workflows. So this does not prove that Laya is simply an open-source Jev replacement. What it does show is arguably more interesting: Modern encoder models can be trained to perform this style of decision making extremely efficiently. And Laya isn't the only experiment happening here. There are already projects called OpenJev exploring whether existing open models can be used differently. Instead of asking a model to generate an answer and then parsing that answer, some experiments inspect the model's probabilities directly and turn those probabilities into decisions. One implementation uses DiffusionGemma. Other experiments have tested models such as Qwen. There are also projects such as GLiNER2 and GLiNER2.5. GLiNER isn't trying to reproduce Jev exactly. Instead, it uses schema-conditioned encoder models. You provide the model with the kinds of information you're looking for — entities, labels, records, relationships — and one relatively small model can perform multiple information-extraction and classification tasks. GLiNER2.5 currently ranges from a 74-million-parameter small model to multilingual models under 300 million parameters. And then there's vLLM Semantic Router. Its job is exactly what the name suggests. Before sending every request to some enormous expensive model, use much smaller semantic models to understand what the request is and decide where it should go. Taken individually, these projects look like different tools solving different problems. But zoom out, and there's a pattern. And surprisingly, that pattern goes all the way back to BERT. I'm going to divide this history into four generations. These aren't official industry categories. They're simply a useful way of understanding how we got here. Generation One: Task-Specific NLP. Generation Two: Universal Language Encoders. Generation Three: Programmable Semantic Models. And now: Generation Four: Decision Models. Before modern transformers, NLP systems were often built around specialized models. You might have one system for sentiment analysis, another for named entities, another for classification. Then, in 2018, Google introduced BERT. And BERT changed NLP dramatically. BERT stands for Bidirectional Encoder Representations from Transformers. Unlike a modern GPT-style model whose defining behavior is generating the next token, BERT is an encoder. It reads the input and creates rich contextual representations of what that input means. And then you can attach a relatively small output layer and fine-tune the model for a particular task. Sentiment. Classification. Named entities. Question answering. Intent detection. So here's the funny part. We've been doing powerful non-generative language understanding for years. Then generative LLMs became extraordinarily capable. Models like GPT showed that instead of building and training a separate system for every task, you could describe what you wanted in natural language. One model could classify something... then write an email... then summarize a document... then write code... then call a tool. The flexibility was revolutionary. But we also started using generative models for jobs where generation wasn't actually necessary. Meanwhile, encoder models didn't disappear. They kept evolving. BERT led to models such as RoBERTa and DeBERTa. Then newer systems such as ModernBERT updated the architecture with modern transformer techniques. ModernBERT was trained on two trillion tokens and supports an 8,192-token native sequence length while retaining the efficiency advantages of an encoder. Then models like GLiNER pushed things further toward runtime programmability. Instead of saying: “I trained this classifier to recognize these three things,” you increasingly move toward: “Here are the things I'm looking for. Find them.” Semantic routers extended the same idea into AI infrastructure. And that brings us back to 2026. What I'm going to call Decision Models push this concept one step further. Traditional classifiers tend to be specialized. Generative LLMs are extraordinarily flexible, but their native output is language. Decision models are trying to occupy the space in between. Give them arbitrary state. Describe the decision you want. Get back something your software can immediately act upon. A category. A score. A probability. A tool call. Structured data. And different projects are approaching this from very different directions. Jev is building a proprietary architecture specifically around calibrated decisions. Needle is asking how tiny this kind of intelligence can become. Laya demonstrates that modern BERT-style encoders can be adapted into surprisingly capable typed-decision systems. GLiNER approaches the problem through programmable schemas. And OpenJev-style experiments are asking whether existing open models already contain these capabilities and we simply need to access them differently. Which brings us to why I think this space matters. Imagine an AI coding agent working for twenty minutes. It might need a powerful reasoning model to understand a difficult bug. But between those difficult reasoning steps, it makes dozens — potentially hundreds — of much simpler decisions. Which tool should I call? Did that command succeed? Which file is relevant? Does this result answer the question? Should I retry? Is this potentially dangerous? Which model should handle the next task? Has the task finished? Does this require human approval? Many of these answers might ultimately be represented by a single integer, category or boolean. Using a giant generative model for every one of them is a little like hiring a novelist every time your program needs an if statement. And that's why I don't think the interesting story here is simply: “Is Jev better than an LLM?” That's probably the wrong question. The more interesting possibility is that the AI stack itself becomes increasingly specialized. A powerful generative model handles difficult reasoning, coding and communication. A retrieval model handles memory and search. An embedding model handles similarity. And fast decision models handle the enormous number of small judgments required to keep the whole system moving. In that world, giant LLMs don't disappear. They simply stop doing every job. And perhaps the most interesting thing about Jev, Needle and Laya isn't that they invented an entirely new idea. It's that they're bringing us back to an idea that BERT demonstrated years ago: Understanding language and generating language are not the same problem. For a while, generative AI made it convenient to treat them as if they were. Now we may be starting to separate them again. And if AI agents become increasingly important, that separation could matter a lot.