The industry has spent the last few years making frontier models better at chat. But what if the model didn’t need to talk at all?
That’s the bet that TypeSafe AI is making, and one that has everyone talking. Jev is the company’s first “System One” model, a new class of AI designed not to generate text, but to make fast, structured decisions that software can act on directly. Instead of returning a paragraph of text, Jev returns answers with probabilities and confidence. Give it a piece of state and a set of questions, and it produces decisions that can immediately feed into the rest of an application.
That might sound like a relatively small change. But it isn't.
Voice is unforgiving about latency. There's no spinner, no progress bar, just a pause. For developers building agents, and especially voice agents, a surprising amount of what we ask an LLM to do today isn't actually “generate language.” It is deciding what should happen next. Which skill should handle this? Is this request safe to execute? Should it call a tool? Which tool? Should it ask for a follow-up or just do it?
These are decisions, not conversations. And treating every decision as a conversation can be expensive, slow, and unnecessarily unpredictable.
A new class of model
The question TypeSafe asked: models have been superhuman at chat for years, so where is all the automation?
Their answer is a new class of model called System One models, named for the fast, intuitive half of Daniel Kahneman's Thinking, Fast and Slow. System 1 describes fast, intuitive judgments, while System 2 describes slower, more deliberate reasoning.
The analogy is useful for AI because the industry has spent enormous amounts of effort making models better at the second half. Frontier models can reason through complicated problems, synthesize large amounts of information, write code, and carry out multi-step tasks with the help of harnesses. But most software doesn't need deep reasoning at every step. In other words, we’ve been unnecessarily using a general-purpose technology for relatively narrow decisions.
The first System One model is Jev. Jev is designed around three basic types of decisions:
Choice, where the model selects from a defined set of options (up to 255)
Score, where it evaluates something against an ordered scale
Noul, which answers a yes-or-no question with a probability. Multiple questions can be evaluated against the same state in a single request.
The result isn't free-form text. It is a value an application already knows how to handle. Think of it as a frontier-intelligence function call. Messy state in, decisions out.
That distinction is important. If an LLM is asked to classify a request as “music,” “weather,” or “smart home,” it might return one of those labels, but it is still returning language. With Jev, the possible answers are defined ahead of time, so the model cannot invent a new category.
That doesn't mean Jev can never make a wrong decision. It can. The important difference is that its output is constrained to the decision space you define, and its confidence can be used to decide whether to act, ask for clarification, or pass to another model.
Why it matters
A voice assistant shouldn't need a frontier reasoning model to decide whether “turn the kitchen lights off” is a lighting request. An agent shouldn't need to generate a paragraph to decide whether a tool call is safe. A customer-service system shouldn't need full reasoning to determine whether a message is urgent.
These are small judgments sitting inside much larger workflows.
The result with Jev: 70 to 500 millisecond end-to-end response times and $0.042 per million input tokens. That’s roughly 200x faster and 400x cheaper than comparable LLMs on System One-shaped tasks.
But the exact multipliers are less interesting than what this makes possible: when intelligence becomes cheap and fast enough, we can afford to put it in places where we previously wouldn't have used AI at all. And that’s especially true with voice, where latency is the difference between a smooth user experience and minutes of silence.
How it works
An LLM generates one token at a time, each conditioned on the last. Jev skips that. It evaluates every question at once and returns values from an answer space defined in advance. It's trained with a method TypeSafe calls Reinforcement Learning for Calibrated Decisions, which optimizes for honest probabilities rather than answers a human rater would like.
This means two things:
It can't return a malformed answer. The schema is the contract. Jev can't produce an invalid value, but it can still produce a wrong valid one. Zero type errors is not zero mistakes.
Confidence is a real number. Across a group of predictions, answers marked 0.9 are right about 90% of the time. That lets you set thresholds by consequence: a low bar for less important decisions, a high bar for moving money.
Another important part of the architecture is that Jev can evaluate multiple questions about the same state in a single request. That means an application doesn't necessarily need to make a series of sequential model calls just to answer a handful of simple questions.
What it means for voice
Voice is where latency becomes painfully visible, and where System One models hold the real possibility.
On a screen, a user can tolerate a loading state. In a conversation, there is just silence. A user doesn't see a progress bar while a voice assistant is thinking. They simply hear nothing. That makes every unnecessary model call matter.
Every decision in a voice loop sits on the critical path, and every sequential step introduces another potential source of latency. And because these steps often depend on one another, adding more intelligence can make the experience slower rather than better.
Jev doesn't eliminate the LLM. Instead, it reduces the number of things the LLM has to be responsible for. For voice, that is particularly relevant because the number of decisions happening during a conversation is much larger than the final response might suggest.
Consider a simple request: “Hey, play the new Bon Iver album, but not in the living room—put it on in the kitchen.”
An agent has to determine what the user wants, identify the content, understand the correction to the target room, resolve which device should play it, determine whether the user is authorized to control that device, and potentially decide whether additional clarification is required.
The final response might be as simple as “Sure.” But getting to that response involves a surprisingly large number of decisions.
Today, we tend to push many of those decisions onto the LLM, or purpose-built tools like daemons, because it is the most flexible system available. System One models suggest a different architecture. The pattern could include specialized decision models and a larger reasoning model, with each layer handling the parts of the problem it is best suited for.
That could look something like: Wake word → STT model → Jev (decision model) → Ability, skill, tool selection → LLM when needed → TTS model → Speaker
Jev could attack silence in a number of ways:
Intent routing. "Turn off the lights" and "book me a flight to Austin" shouldn't take the same path. A Choice question could pick the right Ability in a fraction of a second.
Model routing. A fast, cheap model can be used for a weather question, while a stronger agent and model can be used for a multi-step task. Jev decides which, per request.
Confidence-gated actions. Below a threshold, the agent asks "did you mean...?" instead of guessing. Above it, it just acts.
Guardrails. Score and block risky tool calls before they execute, without adding a second slow LLM call to the loop.
Turn-taking and tone. Is the user finished, or just pausing? Frustrated or relaxed? Cheap, parallel questions on every utterance.
All of this could make voice interfaces feel substantially more responsive, and conversational.
And just as importantly, it changes the way we can think about designing them. Instead of sending every interaction through one large model or agent and asking it to figure everything out, we can distribute the work across models that specialize in different types of decisions.
There are already early experiments pointing in this direction.
What people are building with Jev today
Developers are already experimenting with Jev in real-time applications, games, trading systems, and voice. Developers have used Jev to evaluate multiple aspects of conversations, including intent, safety, agreement, and whether a conversational step is complete.
It’s only been a couple of weeks, but the early Jev ecosystem gives a good indication of where these models are useful - they involve making a large number of relatively small decisions where latency, cost, and predictable outputs matter.
1kpapers.com classified 1,018 research papers for about eight cents.
A browser agent books a Zürich-to-London flight on Google Flights in 7.1 seconds for under half a cent, asking the click, type, and select questions in one round trip and executing only the matching one.
Computer use without screenshots. One project drives a Mac using OCR plus Jev, at roughly a fiftieth of a cent per step, versus several cents for a frontier model looking at pixels.
A drone flies an obstacle course in simulation with Jev providing advisory judgment at about 2.5Hz. Ordinary code keeps ownership of safety and control.
A live trading agent, email triage at scale, Super Mario from RAM, StarCraft missions, and Doom from TypeSafe itself.
What’s clear is that Jev is most useful when an application needs to make lots of decisions, quickly, inside a constrained decision space. The pattern across all of them: keep the loop and use Jev for narrow judgement in the middle.
Toward a new architecture
For the past few years, the default answer to almost every AI problem has been: give the model more context and ask it to figure things out. That approach has worked remarkably well, and increasingly capable frontier models will continue to be at the center of AI systems.
But as AI moves from chat windows into homes, cars, and everyday software, we are going to need more than models that are simply good at generating language, we need models that can make decisions quickly, communicate uncertainty, and provide outputs that software can consume predictably.
Jev isn't designed to replace the LLM. It doesn't write a response, explain a complicated concept, compose an email, or reason through an open-ended problem. For a voice assistant, an LLM can be used to understand a complicated request and formulate a natural response, while Jev handles the dozens of smaller decisions surrounding that interaction.
The best voice interfaces may not have one model at their center. They may have a collection of models, each responsible for a different kind of intelligence: one that listens, one that decides, one that reasons, one that remembers, and one that speaks.
Join us in building the future of voice
At OpenHome, we’re building a future where AI is freed from chat to become an ambient intelligence layer woven into everyday life. OpenHome provides the hardware, platform, and community that enable developers to create voice-first experiences for the physical spaces people work and live in.
Through our open-source Voice SDK, local models, sensor layer, and DevKit, OpenHome turns a home device into an intelligent, conversational interface that can listen, sense, understand, and act in the real world.
To learn more, join our Discord, read our blog, and check out our developer docs.