Jev and System One Models: Fast Classifiers for AI Agents

A System One model is an AI model that makes fast, structured decisions instead of writing text. TypeSafe AI's Jev, launched September 15, 2026, takes a state and your questions and returns typed answers with probabilities. LangChain has already built routing and guardrail middleware on it. The speed gains are real, but early independent tests show smaller wins than the headline 200x.

Key Takeaways

• Jev, from TypeSafe AI, is the first System One model: it answers structured questions with probabilities and doesn't generate text.
• TypeSafe claims 70 to 500 millisecond responses and input pricing of $0.042 per million tokens, with output free.
• Its headline speed-up figures range from 20x to 193.6x across its own materials. Early independent tests found gains closer to 5x to 10x on real tasks.
• In 6,003 rubric checks, Jev matched Claude Fable 5.1's verdict 91.5% of the time at roughly 1/200th of the cost.
• For agent builders, the best fit is fast decisions inside the loop: routing, triage, and guardrails, with an LLM still doing the reasoning.

What Is a System One Model?

A model that decides rather than writes. You give it a situation and a set of typed questions, and it returns answers your code can use directly.

Reported fact: TypeSafe AI introduced the term and Jev on September 15, 2026, when it also came out of stealth. It describes System One models as "a new class of frontier models built to make fast, structured decisions that software can use directly." The name borrows from Daniel Kahneman's idea of fast, intuitive thinking.

Jev supports three kinds of questions:

• Choice. Pick one option from a set, with a probability for each option.
• Score. Rate something on ordered levels, like low, medium, and high.
• Noul. A yes-or-no question that returns the probability the statement is true.

It answers every question in a request at the same time. So asking five questions about one ticket costs little more, and takes little longer, than asking one.

TypeSafe trains Jev with a method it calls reinforcement learning for calibrated decisions, or RLCD. The goal is that a 90% answer is right about 90% of the time. That calibration is what lets your code act automatically above a threshold and hand everything else to a person.

How Does a System One Model Fit the Agent Loop?

As a fast decision step between the expensive ones. An agent loop runs model call, tool call, evaluation, repeat. Many of those decisions are small classifications that don't need a full LLM.

LangChain's write-up frames it this way: use an LLM for open-ended reasoning and generation, and Jev "for fast, structured decisions along the way." Its integration exposes Jev through a TypeSafeClassifier that takes a state and questions and returns typed results:

from langchain_typesafe import Noul, TypeSafeClassifier

classifier = TypeSafeClassifier()
response = classifier.invoke(
    state="The deploy failed twice and customers are seeing 500s.",
    questions={"urgent": Noul(instructions="Does this need attention right now?")},
)
urgency = response.nouls["urgent"].noul

The state can be plain text, structured data, or the messages your agent already has, so it slots into a node or middleware hook without reshaping your context.

Where Can You Use a System One Model in Agents?

Anywhere an agent currently spends a full LLM call on a yes, no, or pick-one decision. LangChain shipped two patterns as experimental middleware.

• Model routing. Jev reads the request and picks a cheaper model for simple lookups or a stronger one for hard problems, based on criteria you write. The choice and its probabilities stay in agent state.
• Auto mode guardrails. Jev checks tool calls for risky actions, such as a destructive shell command, and blocks them before they run.
• Triage and prioritization. Scoring urgency, sentiment, or category on incoming tickets and messages.
• Evaluation verdicts. Grading agent outputs against a rubric, where Jev's low cost makes checking every output affordable.
• Stop conditions. Deciding whether a task is done, or whether the agent should escalate to a person.

The guardrail pattern is worth a closer look. LangChain notes that coding tools already classify dangerous actions before running them, but that step has mostly lived in closed-source parts of those products. A cheap classifier makes the same pattern practical for any agent. We cover the wider safety picture in agentic AI security.

How Fast and Cheap Is Jev, Really?

Faster and cheaper than an LLM on its tasks, but by less than the headline number. The claims vary even within TypeSafe's own materials.

Reported fact: TypeSafe cites 70 to 500 millisecond responses against 3 to 329 seconds for frontier LLM calls, and input pricing of $0.042 per million tokens with output free. According to a critical review by The Cherry Creek News, its homepage shows 193.6x faster and 444.6x cheaper, its blog says 40x to 200x, the founder's thread says 20x to 200x, and a latency example on the same page works out to about 75x.

The same review points to a deeper issue. TypeSafe scored its own evaluations against reference answers set as "the average of GPT-6 Astra and Fable 5.1," a method the company itself said "biases answers towards OpenAI and Anthropic's models." That measures agreement with frontier models, not correctness.

Test	Who ran it	What it found
Vendor workflow evals	TypeSafe AI	20x to 193.6x faster, up to 444.6x cheaper
Event classification	Near Here, a UK events company	96% accuracy, about 5x faster and 8.6x cheaper than Mistral Small 4
6,003 rubric checks	Good Start Labs, via Langfuse	91.5% agreement with Fable 5.1, at $160 vs $33,000 per million answers
Planted defects	Every	Caught 6 of 7, against 7 of 7 for Fable 5.1

The honest read: a 5x to 10x gain with accuracy in the 90s is still a very good result for classification work. The problem is only the headline. Plan your costs on the independent numbers, not the marketing ones.

How Accurate Is a System One Model Compared With an LLM?

Close enough for many decisions, not identical. The most useful comparison so far is also the most nuanced.

Reported fact: In Langfuse's write-up of a Good Start Labs test, five models graded the same 6,003 rubric checks. Jev matched Claude Fable 5.1's verdict 91.5% of the time at $160 per million graded answers, against $33,000 for Fable 5.1. DeepSeek V4.1 Flash matched 93.5% of the time at $260, GPT-5.6 Luna cost $400, and Gemini 3.8 Flash cost $1,600.

Two things stand out. First, a cheap LLM came close on both agreement and price, so Jev's edge over budget models is real but modest. Second, the 8.5% of cases where Jev disagreed are where your risk lives.

The honest read: agreement with a frontier model is a proxy, not proof. For decisions that matter, measure Jev against labels your own team has checked, which is the same discipline we recommend in AI agent evaluation.

What Are the Limits of a System One Model?

It can't do anything that needs text out. That's by design, and it rules out a lot.

• No generated text. It can't write a reply, summarize, or explain its answer in words.
• Bounded choices. TypeSafe says questions support up to 255 options.
• Text and data only. Jev reads text and structured data, not images, for now.
• Early access. It's available through a waitlist and isn't downloadable, so you depend on TypeSafe's hosted service.
• Young claims. The company launched this week, and long-term pricing and reliability are unproven.

TypeSafe also says Jev "can't hallucinate." That's true in a narrow sense: it can't return a field or option outside your schema. But it can still pick the wrong option, which is a mistake that matters just as much.

How Should Teams Adopt a System One Model?

Carefully, on one decision at a time, with your own data as the judge. Here's a sensible path.

• Pick a high-volume, low-stakes decision first. Ticket routing or model routing is ideal. A wrong answer costs a little money, not a customer.
• Build a labeled test set. Pull 200 to 500 real examples and have your team mark the right answers.
• Compare against your current model. Measure agreement, cost, and latency side by side on that set.
• Set a confidence threshold. Let Jev act above it, and send lower-confidence cases to an LLM or a person.
• Keep a fallback. If the service is slow or down, route decisions to your existing model rather than stalling the agent.
• Log every decision. Store the question, answer, and probability, so you can audit mistakes later.

That threshold step is where calibration earns its keep. If a 95% answer really is right 95% of the time, you can tune exactly how much work Jev handles alone. Our guide to human review loops for production AI agents covers how to design the handoff.

Should You Use Jev or a Small LLM?

It depends on what the decision needs. The Good Start Labs numbers show a budget LLM can come close, so Jev isn't automatically the right pick.

Jev tends to win when:

• Latency matters. Decisions inside a live loop, like routing or guardrails, benefit most from sub-second answers.
• You ask many questions at once. Parallel questions barely add time or cost, while an LLM grows slower as you ask more.
• You need probabilities. Calibrated scores let you set thresholds. An LLM's stated confidence is much harder to trust.
• You need guaranteed structure. Jev can't return an option outside your schema, so there's no parsing or retry logic.

A small LLM tends to win when:

• You need a reason. If a person or an audit log needs an explanation, you need generated text.
• You need images. Jev reads text and structured data only for now.
• You need to self-host. Open-weight models can run on your own servers. Jev runs only as TypeSafe's hosted service.
• You can't take vendor risk. A startup that launched this week is a bigger dependency than an established provider.

The honest read: many teams will end up using both. A System One model handles the fast, high-volume decisions, and a small LLM handles the cases that need words. The choice for each decision should come from your own test set, not from either vendor's chart.

What Does Jev Mean for Agent Costs?

That the cheap parts of an agent can finally be cheap. Many agents spend a large share of their budget on small decisions that don't need a frontier model.

Take an agent that makes 10 routing or safety checks for every real reasoning step. If each check moves from a mid-sized LLM call to a System One call, the check portion of the bill can fall several times over. The independent test above measured 8.6x cheaper against a small model, and the gap grows against larger ones. The reasoning calls cost the same as before.

That's the right way to think about it: not replacing your model, but moving the small decisions off it. We break down where agent budgets actually go in AI agent development cost.

How Van Data Team Helps Teams Build Faster, Cheaper Agents

We help teams design agent loops where each decision runs on the cheapest model that can do it well. That means finding the classification steps hiding in your workflows, building labeled test sets to compare models honestly, and adding the thresholds, fallbacks, and logs that make fast decisions safe.

A System One model like Jev is a promising new tool for that work, not a shortcut around it. If you want to find out where it could cut your agent costs without cutting accuracy, our work on AI agent evaluation and designing AI agents with human review loops is a good place to start.