A new class of "System One" models skips text generation. Here's why that matters for app developers.
Most of your AI calls are overkill
Think about the last few times you called an LLM from an app. How many were for writing an essay, and how many were for a simple judgment: Is this spam? Which team owns this ticket? Is this urgent?
Most of us are paying a model to write a sentence, then parsing that sentence back into a label. That's the gap two new models are built for: Jev from TypeSafe AI and Laya from Convai Innovations.
What is a "System One" model?
The name comes from Daniel Kahneman's split between fast, intuitive thinking (System 1) and slow, deliberate reasoning (System 2). The bet is simple: most decisions inside software are quick System 1 judgments, and we've been renting expensive System 2 models to make them.
The key technical difference:
- LLMs generate answers one token at a time. Latency grows with output length, and the answer arrives as a free-form string you still have to parse and validate.
- System One models return a decision directly. You define the possible answers up front, and the model picks one and tells you how confident it is.
Jev: the closed, cloud-first pioneer
Who's behind it: TypeSafe AI, a San Francisco startup founded in 2024 by Diogo Almeida, Sasha Sheng and Erik Gafni. Almeida previously worked at OpenAI on RLHF and InstructGPT. Jev launched in early access on September 15, 2026, alongside a $40M seed round led by DCVC.
How it works: You send a state (text or JSON) plus a set of typed questions. Each question is a Choice (pick from a list), a Score (rate on a scale), or a Noul (yes/no probability). All questions are answered in parallel, in a single call.
Speed and cost: Responses take roughly 70 to 500 ms. Input is priced at $0.042 per million tokens, and output is free, because there's no token-by-token generation loop to pay for.
Training: TypeSafe uses a method it calls Reinforcement Learning for Calibrated Decisions (RLCD), which optimizes probabilities against real outcomes rather than human preference ratings. In plain terms, a 90% confidence score should actually mean it's right about 90% of the time.
The catch: TypeSafe hasn't published Jev's architecture, weights, or a technical paper. It's a black box behind an API.
Laya: the open-source challenger
Who's behind it: Nandakishor Mukkunnoth, founder of Convai Innovations, who has been building solo since March 2025. Laya was released on September 18, 2026, just three days after Jev, under the Apache 2.0 license, with weights on Hugging Face and a simple pip install laya.
What's under the hood: Three checkpoints:
- An English base on ModernBERT-large (421M parameters, 512-token context)
- A multilingual variant on mmBERT-base (322M parameters, 1024-token context, 100+ languages)
- A checkpoint fine-tuned specifically for typed decisions
Speed: Around 33 ms per decision on a single GPU.
Why developers care: It runs locally. One developer has already run the 421M model entirely inside a browser tab, with no server and no API key.
Head-to-head
| Jev | Laya | |
|---|---|---|
| Maker | TypeSafe AI (funded startup) | Convai Innovations (solo founder) |
| Access | Closed API, early access | Open weights, Apache 2.0 |
| Size | Undisclosed | 322M to 421M parameters |
| Latency | 70 to 500 ms | About 33 ms on one GPU |
| Runs locally? | No | Yes |
| Best at | Zero-shot decisions out of the box | Fine-tuned, domain-specific decisions |
Laya's author reports benchmark wins over Jev 1.13.0, including 0.766 vs 0.727 on a 2,000-decision typed-decisions test and 0.950 vs 0.910 on AG News.
The honest reality check
Before you swap Jev for Laya, read the fine print. Laya's own model card describes it as a fast base to specialise, not a zero-shot decision engine. One independent comparison found that without fine-tuning, it can score below a simple majority-class baseline.
So the fair summary is:
- Choose Jev when you want good decisions immediately, with no training.
- Choose Laya when you have labeled data and want a fast, private, free model tuned to your domain. The project ships training and fine-tuning tooling alongside the weights, and that's where its real value lies.
And neither one replaces your LLM. They work best next to one: routing requests, reranking results, checking citations, judging tool calls, and verifying outputs.
Why this matters for Android developers
This is the part I'm most excited about. A 322M to 421M model sits in the size range where on-device inference starts to look realistic, though nobody has published solid mobile benchmarks yet. If it works, the architecture looks like this:
| Layer | Job |
|---|---|
| Rules | Deterministic cases (regex, thresholds) |
| Laya, on-device | Fast, private decisions: classify, route, flag |
| Cloud LLM (Gemini, Claude) | Hard reasoning and text generation |
| Human | High-impact approvals |
Picture a notes app that tags entries by mood, a support app that routes tickets before they leave the phone, or a finance app that flags suspicious SMS offline. These are simple decisions that shouldn't cost a network round trip or send private data to a server.
The takeaway
Jev proved the idea. Laya opened it up. Together they point to a new layer in the AI stack: small, fast, calibrated decision models sitting in front of the big generative ones.
The question for your next app isn't "which LLM should I use?" It's "how many of these calls never needed an LLM at all?"
Sources
- Jev (AI model) on Wikipedia
- What Is Jev? (Firecrawl)
- How to Use Jev (DEV Community)
- Laya: The 33ms Open-Source Decision Model (Mervin Praison)
- Jev vs Laya (OrcaRouter)
- Convai ships Laya (AI Weekly)
— ByteBrain Apps · Calm interfaces. Intelligent motion.