Meet Jev: AI Built to Decide, Not Generate
Jev, a System One model from TypeSafe AI, offers an interesting glimpse into a different approach to AI-powered decision-making.
Technology is moving at break neck speed, keeping pace is becoming increasingly difficult. I wanted to write about Jev, a new one of its kind model that was recently launched. I usually take some time to write about anything in technology. I like to study, understand how it works and try it out before I put my thoughts down. By the time I could write about Jev, the market was flooded with the likes of Jev including other proprietary models like Microsoft-decision-1 and open source alternatives like Laya and Open Jev. But I still decided to continue writing about Jev more as a representative than particularly about Jev itself.
In this month TypeSafe AI, a company started by Diogo Almeida, a former employee of OpenAI launched a new AI model called Jev. Unlike the other frontier models this model does not generate text. It helps in decision making.
Almeida's experience working on ChatGPT-related systems led him to question whether conversational models were the right tool for every automation task. Models optimised to generate helpful responses are useful for many applications, but software often needs something different: a structured decision that can be consumed directly, without generating and interpreting a paragraph of text. He left OpenAI in 2024 to fix this exact architectural problem by creating TypeSafe AI.
Jev is TypeSafe’s flagship model and the first System One model. System One models are a class of AI models built to make fast, structured decisions that software can use directly.
The System One name comes from the concept Daniel Kahneman popularized in his book Thinking, Fast and Slow. System 1 thinking is fast and intuitive. System 2 is slower and more deliberate. Here, the emphasis is on fast, focused judgments.
Is Jev another LLM?
Jev differs from conventional LLMs in how it is designed to produce its output. While traditional LLMs generate text, Jev is designed to make structured decisions from textual context. Rather than generating open-ended responses, it evaluates predefined questions and returns typed outputs such as choices, scores and probabilities. Its underlying architecture differs from that of conventional generative models, with the emphasis on decision-making rather than text generation.
No text generation
Jev cannot compose sentences, write code, or output open-ended strings. Traditional LLMs construct paragraphs, write code, draft emails, and engage in open conversational back-and-forth. Focuses strictly on selection from choices. Instead of writing new text or sentences, it evaluates input context against explicit options and selects results with attached probabilities.
Structured Outputs Only
You pass Jev a state (like text or JSON) alongside a pre-defined set of closed questions. It evaluates the entire schema and returns typed, probabilistic decisions (e.g., picking from a list, a yes/no probability, or a numeric scale). Jev executes selection from choices using three distinct question types:
Choice: Selecting an option from predefined criteria (e.g., routing of support tickets to billing, technical, or sales).
Score: Selecting a score or a range. (e.g., rating customer satisfaction from dissatisfied to Happy).
Noul: Selecting a binary true/false judgment and returning a direct probability value between 0 and 1 (e.g., marking an email as 96% Spam vs Not Spam).
How it is used in code
Software code that consumes an LLM typically sends a context or prompt to the LLM and receives a text response. The output is usually free-form text or structured JSON, which the application backend must parse and interpret before the code can take action.
Jev works differently. Instead of returning text, it returns a selected choice against the question ID supplied in the input. The calling code can immediately consume the selected choice, its associated probability, and confidence score, and use these values to decide the next branch or route the request.
What are the places where Jev can be best used?
Jev was explicitly designed to sit alongside generative LLMs in software pipelines as a "System One" fast decision layer. When building software workflows (including agentic systems), there is an entire class of small decisions that must be made continuously based on intermediate LLM outputs, state changes, or user inputs.
Here are the 5 key places where Jev is best used in a pipeline:
Choosing the next model in agentic pipelines
When building smart AI workflows, you don't need to use a heavy, expensive model for every single step. Jev can help in checking the job details and deciding the right model for the next step by balancing cost, speed, and accuracy.
Deciding the next action in your workflow system
During a workflow, when a user takes an action or an AI finishes a task, your software needs to know where to go next. Jev looks at the situation and picks a clear next step such as running the task automatically, sending it to a human or stopping it.
Guardrailing tool calls before execution
If an AI wants to take an important real-world action (like issuing a refund or deleting data), Jev can act as a safety guard. It can look at what the AI wants to do and gives a simple thumbs-up or thumbs-down (allow, confirm, review, or deny) so that the system can act safely. Jev never executes the action itself; it aids in making the decision.
Checking if a job is really done
Before an AI tells a user "I'm finished," Jev can act as a quality inspector. It can check what was requested against what was actually completed and answers whether the job is fully done, incomplete, or needs extra checking.
Keeping memory clean in long conversations
This one is the most useful. Even if the model context lengths are increasing, they are still limited. The decision of what should go into the context so as not to dilute the model’s memory is a very important design decision for RAG systems. During long back-and-forth AI tasks, conversation history can get cluttered with useless information. Jev can act as a filter by picking out only the important facts that need to be saved for the next turn.
Jev Alternatives
And as I mentioned earlier, I took a little while to write this article because I wanted to spend some time understanding Jev and, more importantly, actually try it out myself. But that’s the funny thing about writing about AI these days. The world moves faster than the article does! Before I could even get to this point, other open-source alternatives to Jev had already emerged. This section was definitely not part of my original plan, but here I am, adding it because I thought you might find these alternatives interesting too. And yes, I’ve tried one of them, Laya, myself. Now, the alternatives …
Microsoft-decision-1: Released by Microsoft on October 9, 2026, Microsoft-Decision-1 is a decision-scoring model designed for single-pass probability calibration, fast ticket and workflow routing, and high-accuracy agent control within enterprise systems.
Laya: Introduced by Nandakishor M / Convai Innovations on September 19, 2026, Laya is a 421M-parameter open-weights decision model used for fast ticket routing, in-browser workflow automation, and real-time safety gating without sending data to an external server.
OpenJev: Developed by community maintainers (SiliconLabAI and razorback16) on September 21, 2026, OpenJev is an open-source, drop-in replacement for the Jev API designed to run locally on your own hardware or server for private workflow routing, memory reranking, and agent decision-making.
Kev: Created as an open-community project (led by developer Jared Palmer) in late September 2026, Kev is a lightweight 0.6B to 9B model used for self-hosted probability calculations, automated code review gating, and local task triage.
Nimble: Released by Bespoke Labs on September 24, 2026, Nimble is a 9B open-weight model tuned specifically for high-accuracy candidate scoring, evaluation-tree classification, and model-routing inside local agent pipelines.
My Findings
I started exploring Jev because I wanted to detect topic shifts in chatbot conversations. But when choosing a model for production, accuracy is only part of the equation. Cost and dependability matter just as much, especially when the model needs to be called frequently. So I decided to compare three options, spanning open-source and proprietary models.
I began with Laya, a local open-source model. While running it locally was appealing, it struggled to detect subtle topic changes and often returned surprisingly low or even reversed probability scores for obvious shifts.
The managed cloud APIs were a different experience. Both Jev 1.13 and Microsoft-Decision-1 performed well in my tests, producing consistent probability scores with simple state and question inputs.
For my topic shift detection use case, the cloud decision APIs made the implementation much more straightforward. It was a useful reminder that the best choice for production isn't necessarily the model that's easiest to run locally. It's the one that delivers the right balance of accuracy, dependability and cost.
Closing thoughts
I find Jev interesting because it makes me wonder whether we are beginning to see another category of AI models emerge.
Traditional predictive models are good at making predictions and classifications, but they are often built around specific tasks. Generative AI changed the game by giving us models that can work with natural language and be adapted to a wide range of applications. Yet, when it comes to making structured decisions that software can act upon, we still have a different set of requirements.
Jev addresses this need in an interesting way. It accepts contextual information and questions expressed in natural language, but instead of generating a response, it returns structured decisions and probabilities. It brings together some of the flexibility we associate with generative AI and the decision-oriented outputs we associate with predictive models.
Could this become a third category of AI models, alongside predictive and generative AI? I think it is an interesting possibility. If models like Jev prove useful across enough applications, I would not be surprised to see more models designed specifically for decision-making, classification, scoring and other tasks that software needs to perform reliably.
Perhaps we are moving towards a world where AI models are not distinguished only by what they can learn or generate, but also by the kind of job they are designed to do.
Comments