TypeSafe AI's Jev returns typed decisions in 0.4s at $0.0004 per case, matching GPT-5.6 Terra's 67.9% at 1/76th the cost. Where it fits, and where it doesn't
Most of what an AI agent does all day isn't writing. It's deciding. Is this ticket urgent? Is this tool call safe? Should this invoice get paid? This week, a $40 million startup called TypeSafe AI shipped a model built only for that job. It refuses to produce a single sentence of prose (The Register, TypeSafe AI debuts model for machines that plays Doom, September 2026).
The model is called Jev. Instead of text, it returns typed answers with probabilities attached, usually in well under half a second. On TypeSafe's own four-workflow benchmark, it matches GPT-5.6 Terra's accuracy at roughly 1/76th of the per-case cost. That's a big claim. However, the benchmark has a catch worth understanding before you rebuild anything around it. Here's what Jev is, what the numbers really say, and where we'd put it in a production agent stack.
Key Takeaways
- Jev scored 67.8% on TypeSafe's workflow evals against 67.9% for GPT-5.6 Terra, at $0.0004 and 0.4s per case versus $0.0304 and 10.1s (TypeSafe AI evals, 2026).
- "Zero hallucinations" means the output shape can't break. The judgment inside it can still be wrong.
- Treat Jev as a fast router and guardrail, not a replacement for your frontier model.
In September 2026, TypeSafe AI introduced Jev as the first of what it calls "System One models," a class of models "built to make fast, structured decisions that software can use directly" (TypeSafe AI, Introducing System One Models & Jev, September 2026). You give it state and typed questions. It gives back typed answers with calibrated probabilities.
The name "System One" borrows from Daniel Kahneman's fast, intuitive thinking. That's the right mental model. Jev isn't meant to reason through a legal brief. It's meant to make the hundred small calls per minute that sit between the steps of an agent loop.
TypeSafe is led by founder and CEO Diogo Almeida, a co-author of OpenAI's InstructGPT paper, and emerged from stealth with $40 million in seed funding (heise online, AI model "Jev" to make machines decide faster, September 2026). Access is early access through a hosted API, with developers coming off a waitlist.
Three terms are worth pinning down before the numbers:
That last point is the whole bet. In fact, it's what separates Jev from a small LLM in JSON mode: the model never writes anything at all. For an overview of how frontier labs are positioning their own flagship models, see our breakdown of whether GPT-6 Astra lives up to OpenAI's AGI-era claim.
In 2026, Jev exposes three question types, according to LangChain's integration guide: Choice, Score, and "Noul," a yes/no question that returns the probability of true (LangChain, What Is Jev? A Guide to TypeSafe AI's System One Model, September 2026). Because answers are computed in parallel, adding questions barely changes response time.
A request is just state plus a dictionary of typed questions. Here's the shape LangChain published:
{ "model": "jev-latest", "state": "Customer: my card was charged twice and the app is down...", "questions": { "is_urgent": { "type": "noul", "instructions": "Does this need a human within 1 hour?" } } }
And the response:
{ "is_urgent": { "type": "noul", "noul": 0.999 } }
As a result, there's nothing to parse. No regex, no JSON repair, no retry loop when the model decides to add a friendly preamble. Your code reads a float and branches on it.
Anthony Maio put it well: Jev behaves like "a learned semantic branch instruction, a component that handles fuzzy judgments while deterministic code stays in control" (Anthony Maio, Jev: The Language Model That Won't Talk, September 2026). We'd go one step further. In practice, it's a smart if statement, and that framing tells you exactly where it belongs. Anywhere your agent currently asks an LLM a yes/no question and then parses the answer, Jev is a candidate.
On pricing, TypeSafe charges $0.042 per million input tokens and makes output free, "too cheap to meter" in the company's words. The official SDKs cover Python and JavaScript, and LangChain ships a langchain-typesafe package with a TypeSafeClassifier wrapper.
TypeSafe tested four workflows: security alert triage, agent trace review, invoice processing, and customer service routing. In September 2026, its published evals put Jev at 67.8% agreement, against 67.9% for GPT-5.6 Terra and 74.1% for GPT-5.6 Sol (TypeSafe AI, Workflow Evals, September 2026). In other words, Jev tied the mid-tier models. It didn't beat the top ones.
Now look at speed and price, where the picture changes completely. Per case, Jev took 0.4 seconds and cost $0.0004. Terra took 10.1 seconds at $0.0304. Claude Opus 5 took 37.8 seconds at $0.1761. Notably, even GPT-5.6 Luna, the cheapest LLM tested, came in at $0.0033 and 12.9 seconds, so Jev is about 8x cheaper and 32x faster than the budget option.
That said, here's the catch. The "reference labels" aren't human ground truth. TypeSafe scored every model against the averaged answers of GPT-6 Astra and Claude Fable 5.1 running at high thinking settings. In the company's words, "we assume that the code is correct, and measure against the current smartest large models." That's a reasonable engineering shortcut, and it's honest about itself. However, it means the benchmark measures how well each model imitates two frontier models, not how often it's right about your invoices. So can Jev ever be smarter than its teacher on this test? No, by construction, it can't. What the evals do prove is that Jev gets roughly Terra-level agreement at a price and latency Terra can't touch.
In short, TypeSafe's own evals show Jev agreeing with frontier-model reference labels 67.8% of the time, level with GPT-5.6 Terra's 67.9%, while costing $0.0004 per case against Terra's $0.0304. Because the labels come from GPT-6 Astra and Claude Fable 5.1, the result measures imitation of frontier judgment, not independent accuracy.
No. In September 2026, DataCamp reported TypeSafe's structured-output error rates as 0% for Jev, 0.58% for GPT-5.6 Terra, 5.73% for Claude Opus 5, and 45.5% for Claude Haiku 4.5 (DataCamp, Jev: TypeSafe's System One Model That Never Hallucinates, September 2026). That 0% is real. It's also narrower than the marketing suggests.
Jev "can't hallucinate" in one specific sense: it can't return an option that doesn't exist or a value of the wrong type. If you ask it to pick from refund, escalate, or ignore, you'll never get back "Sure! I'd recommend a refund." For example, that kills an entire class of production bugs, and anyone who's written JSON repair code knows how big that class is.
In contrast, it doesn't guarantee the right option. Jev agreed with the reference labels on about two-thirds of decisions, which means it disagreed on about one-third. Maio's critique nails the distinction: "Jev constrains the shape of the output. It does not constrain the judgment."
In our experience building agent pipelines for clients, malformed structured output is rarely the failure that ends up in an incident review. Wrong-but-valid output is. A classifier that confidently routes a fraud report to the FAQ bot passes every schema check. So we'd read "zero hallucinations" as "zero parse failures," which is valuable, and keep the evals that catch bad judgment.
In September 2026, TypeSafe listed its early workflows as customer service routing, invoice handling, security alert triage, and review of completed AI agent runs (TypeSafe AI, Introducing System One Models & Jev, September 2026). Every one of those is a high-volume, bounded decision. That's the pattern to match.
LangChain's integration shows two harness patterns that we think are the strongest starting points:
AutoModeMiddleware uses Jev to classify dangerous tool actions before they run. At 0.4 seconds, you can afford to check every call, not a sample.Of the two, the second pattern matters more than it looks. Our analysis of four AI sandbox escapes in four weeks found that the gap was rarely a missing policy. It was that nothing checked each action in real time. A sub-second classifier makes that check cheap enough to be the default.
So where would we not use it? Anything that needs generated text, code, or a written rationale. Anything with an open answer space. And, for now, anything with images, which TypeSafe says it doesn't support yet.
Not yet, and not blindly. In September 2026, TypeSafe described RLCD as training probabilities to line up with real accuracy. Its public materials, however, don't include a calibration metric such as expected calibration error (TypeSafe AI, Workflow Evals, September 2026). The workflows were also built by TypeSafe's own model capabilities team, which the company acknowledges.
Calibration is the feature that makes Jev useful. If is_fraud: 0.92 really means "right 92% of the time," you can set thresholds with a clear conscience. If it doesn't, your thresholds are guesses with decimals. Calibration is also fragile, however. It holds on data that looks like training data. It drifts when your traffic shifts, when a new fraud pattern shows up, or when someone feeds it adversarial input. And thresholds you tune today are coupled to jev-latest, which, as the name says, will change.
So what should a careful team do? For instance, run it in shadow mode first. Log Jev's probabilities next to your current system's decisions for two to four weeks. Then bucket by confidence and check whether the 0.9 bucket is right about 90% of the time on your data. Pin a model version before you set production thresholds. It's the same discipline we recommend in our look at Claude Fable 5.1's breaking changes: never let a floating model alias own a threshold.
In September 2026, The Register noted the obvious risk in TypeSafe's pitch: cheaper decisions tend to mean more decisions, the Jevons paradox the model's name seems to wink at (The Register, September 2026). That's not a bug, though. In fact, it's the strategy.
We've argued before that cheaper tokens often mean a bigger AI bill, because consumption rises faster than unit price falls. Similarly, Jev will probably follow the same curve. Teams that can suddenly afford to check every tool call will check every tool call. That's mostly good. Just budget for volume, not for the per-call price on the launch page.
Meanwhile, the bigger shift is architectural. For three years, the default agent design has been one large model doing everything: reasoning, deciding, formatting, and checking itself. Jev is a strong signal that the stack is splitting. Generative models draft and explain. Small typed models judge. Deterministic code owns state, math, and policy. Humans take the ambiguous, high-stakes cases. That split isn't new in theory. Nevertheless, it rarely paid off in practice, because the judge layer cost almost as much as the model it guarded. What's new is a production API that makes the "judge" layer 76x cheaper than the model it replaces, with no parsing layer to maintain.
Jev isn't a smarter model. It's a cheaper, faster, better-shaped one, and for a big slice of agent work, that's the thing that matters.
Therefore, our recommendation is simple: pick one high-volume decision in your agent, run Jev in shadow mode beside it for a few weeks, and let your own data decide. Pair that with the unit-economics thinking in our piece on how H100 price resets change AI feature costs.
We'll test it against your real workflows, no pitch
Continue exploring these related topics
On a 12 GB test repository, xAI's Grok Build CLI sent about 192 KB to the model and 5.10 GiB to a Google Cloud Storage bucket, What xAI Grok Build CLI actually sends to xAI: a wire-level analysis.
Flash is open-weights and local-ready. FlashX is the hosted speed tier. Compare stats, context length, pricing, and best use-cases.
ChatGPT Health helps you understand lab results, fitness data, and wellness trends using AI—clear explanations, strong privacy, and zero late-night panic.
