+994512060920
On September 15, 2026, an interesting announcement landed: Diogo Almeida, who helped build ChatGPT, came out of two years in stealth to launch TypeSafe AI and its first model, Jev. But Jev isn't a language model in the usual sense, because it doesn't write text at all. Not a sentence, not even a single word. Instead, it returns a structured decision directly, and does it 20 to 200 times faster than a typical LLM, at a fraction of the cost. Alongside the announcement, the company revealed a $40 million funding round led by DCVC.
In this article, we'll cover what Jev actually does, why it's a genuinely different approach, and what it could mean in practical terms for your own AI-powered systems.
What Is Jev?
Jev is the first entry in what TypeSafe AI calls a "System One Model," a new category of model altogether. The name is a nod to psychologist Daniel Kahneman's well-known distinction in "Thinking, Fast and Slow": fast, intuitive "System 1" thinking versus slow, effortful "System 2" reasoning. Jev is built to model that fast, instinctive decision-making, not the slow, step-by-step reasoning LLMs typically handle. That analogy isn't incidental. Almeida's core argument is that not every AI task actually requires deep reasoning.
How Does It Actually Work?
Standard large language models generate text token by token, sequentially. Jev takes a completely different approach: the developer defines a set of possible outcomes upfront (choices, a score, a yes/no decision), and Jev returns those outcomes in parallel, each paired with a calibrated confidence score. The result isn't text. It's a structured response your program can use directly. By design, this approach rules out syntax errors and "hallucinations" from the start, since the model can only output one of the options you've defined. You could think of it as applying the "type safety" concept from traditional programming to the AI decision-making process itself.
Why Is It So Fast and So Cheap?
The numbers here are genuinely striking: Jev responds in 70 to 500 milliseconds, costs just $0.042 per million input tokens, and output tokens are free entirely. One early tester reported running 5,000 requests for about $2 total, with an average response time around 150 milliseconds. This is a sharper, newer example of the trend we covered in our piece on falling AI model prices: for simple classification and decision tasks, there's no longer a need to reach for a massive, expensive model, and that adds up to real savings for systems that make a lot of small decisions.
RLCD: A New Training Method
Instead of the RLHF (Reinforcement Learning from Human Feedback) that standard models are trained with, Jev was trained using a new method Almeida developed himself, called RLCD. The difference is in the objective: RLHF trains a model to produce answers humans rate highly. RLCD instead trains the model to produce confidence scores that are "epistemically honest," meaning they actually correlate with real-world outcomes. Put simply, Jev wasn't trained to please people. It was trained to accurately reflect reality.
It Doesn't Replace LLMs, It Complements Them
Here's an important nuance worth calling out: Jev isn't meant to replace existing chat models (GPT, Claude, Gemini). Instead, it's designed to run alongside them as an additional "decision layer." In Almeida's own words, think of Jev as a "frontier-intelligence function call": unstructured state goes in, a typed, probability-based decision comes out. In a real system, you'd still reach for a large model for complex reasoning, and call Jev for simple routing and classification decisions. This two-layer approach offers a more efficient architecture than trying to make one single model handle everything.
Practical Use Cases
Early users have already tested Jev in a handful of concrete scenarios: figuring out which team a support ticket should route to, classifying user intent, flagging content for safety review, and deciding whether a failed request is worth retrying. This is particularly valuable when building AI agents. Instead of an agent calling a large, expensive model at every single step, handing off simple routing decisions to a fast layer like Jev can meaningfully cut both cost and latency. If only 2 or 3 steps out of 10 in an agent workflow genuinely require creative reasoning, offloading the rest to a fast decision model can noticeably improve the whole system's performance.
Jev vs. a Typical LLM
| Criteria | Typical LLM (GPT, Claude, Gemini) | Jev |
|---|---|---|
| Output format | Free-form text | A decision within a predefined structure |
| Generation method | Sequential, token by token | Parallel, all options evaluated at once |
| Speed | Usually a few seconds | 70-500 milliseconds |
| Primary use case | Creative writing, complex reasoning, conversation | Classification, routing, fast decisions |
| Failure mode | Carries hallucination risk | Output is limited to defined options, so hallucination risk is low by design |
Who Built It?
The name behind TypeSafe AI isn't a coincidence. Diogo Almeida co-invented RLHF at OpenAI, one of the people directly behind the technique that turned GPT-3 from a plain text predictor into something people actually wanted to talk to. As a co-author of the InstructGPT paper, he was directly involved in the work that laid the foundation for ChatGPT. He left OpenAI in 2024 and spent the next two years building a new approach in stealth. That background suggests TypeSafe isn't just "another startup," but a deliberate attempt by someone who knows the industry closely to fill a specific gap.
What Does This Mean for Your Own System?
If your system already relies on AI for classification, routing, or decision-making, calling a large language model for every single one of those requests is often unnecessary overhead. The concept behind specialized "decision models" like Jev points to where AI architecture is likely headed: increasingly layered, with large models handling complex, creative work and small, specialized models handling fast, repetitive decisions. That's worth factoring into how you plan your API architecture, especially if you're dealing with high-volume, simple decision tasks.
Keep in Mind This Is Still Early
Jev isn't in broad release yet. It's in a limited early access phase. Given how new this approach is, questions around explainability and real-world reliability across different industries haven't been fully answered yet. Getting listed on OpenRouter within three days, and developers already wiring it into tools like Claude Code and browser automation, shows fast interest, but like any new technology, it'll take time to prove itself in large-scale production environments. For teams working in banking, government, or other regulated industries, this is worth extra caution, since being able to explain how a decision was reached can sometimes matter more than raw technical performance.
Frequently Asked Questions
Can Jev chat like ChatGPT or Claude?
No, that's not what it's built for. Jev can't generate free-form text at all. It only returns a decision within a predefined structure.
Does Jev replace our existing AI investments?
No. It's meant to sit alongside your existing models, as an additional tool for handling simple decision tasks faster and more cheaply.
Is this technology reliable enough for production?
It's still early stage. The concept looks strong, but careful evaluation is recommended before using it in large-scale, critical systems.
Will this kind of "decision model" become more common?
The trend points that way. As AI costs keep falling and systems automate more decision-making tasks, using the biggest model for every single task increasingly looks inefficient.
Is it hard to integrate Jev into our own project?
The model is accessible via API and has already been listed on platforms like OpenRouter within days of launch, which makes integration relatively straightforward. That said, given its limited track record, careful testing is still worth the effort.
Conclusion
What's most interesting about Jev isn't the specific numbers, it's the underlying philosophy: not every AI task requires writing text. Some just need a fast, honest decision. That distinction is a useful signal for how AI systems are likely to be built going forward: instead of one giant model doing everything, a layered toolkit where each piece is good at its own job. A few years ago, the dominant idea was "let one big model handle everything." The industry is now gradually shifting toward "the right tool for the right task."
If you want to explore how to optimize AI-driven decision-making in your own systems, you can reach out to the Crocusoft team for advice.
