TypeSafe Jev: 0% Hallucination, 67.8% Accurate

TypeSafe AI's new model, Jev, ships with two headline numbers that sound contradictory: a 0% hallucination rate and 67.8% accuracy. Both are true at the same time, and the distance between them is the entire product. On the company's own workflow evals, Jev averages 67.8% across four automation tasks at $0.0004 and 0.4 seconds per run, against 74.1% for the top-scoring model in the same harness. It costs $0.042 per million input tokens with output tokens free, and it is available only to developers coming off an early-access waitlist. It also cannot write a sentence.

Background

TypeSafe AI announced Jev on September 15 as the first of what it calls System One Models, trained with a method it names RLCD, or Reinforcement Learning for Calibrated Decisions. The company is led by Diogo Almeida, who worked on ChatGPT before founding it, and has raised $40 million. The launch post frames the bet plainly: most AI output today is consumed by other software, not by people, and a model that only ever talks to code does not need to produce prose.

So Jev does not. It takes a structured query and returns a typed probabilistic decision, all at once rather than token by token. A support routing call comes back as something like {"billing": 0.08, "technical": 0.85, "sales": 0.07}, which ordinary code consumes without parsing anything. Almeida told The Register that "TypeSafe was founded to pursue an alternative path for AI research, focused on machine-native AI," adding: "I spent years working on models designed to make AI better at interacting with people. But if AI is going to fundamentally change how work gets done, people can't be the only consumers of intelligence."

The demo that traveled was Doom. Jev played it at roughly 10 calls per second, responding in 0.114 seconds against 8.566 seconds for GPT-5.6 Terra, at about $7 for an hour of gameplay. It is a good demo because it is honest about the shape of the thing: a fast, cheap, narrow decider in a loop.

Deep Analysis

Type safety guarantees the shape of an answer, never its correctness

The launch materials say the model "can't hallucinate," "never makes type errors," and carries a 0% hallucination rate. Read literally, these are claims about schema conformance. Jev emits values that fit a predefined structure, so it cannot invent a field, return malformed JSON, or call a tool that does not exist. That is a real and useful guarantee, and it removes an entire class of retry logic from production pipelines.

It is not a claim about being right. A routing decision of 85% technical on a billing ticket is perfectly type-valid and perfectly wrong. The 67.8% accuracy figure on the vendor's own harness is the measurement of exactly that: roughly a third of the time, Jev returns a well-formed answer that does not match the reference. The Register reached the same conclusion, noting that structured outputs still produce incorrect results, just differently than an LLM does. "0% hallucination" and "32.2% wrong" describe the same model without conflict, because they measure different things. Anyone reading the first number as a quality claim has misread it.

The benchmark's ground truth was written by the models Jev replaces

This is the detail that reframes the whole scoreboard. The evals page states that "the reference labels are generated via an average of the responses of GPT-6 Astra and Claude Fable 5.1, both at high thinking, answering every question in the harness." The answer key is not human-labeled ground truth. It is the consensus of two frontier LLMs.

That has a hard consequence: on this benchmark, 100% would mean perfectly imitating GPT-6 Astra and Claude Fable 5.1, not being perfectly correct. Every score in the table is agreement-with-frontier-models, and the ceiling is defined by the systems Jev is pitched as displacing. It is a legitimate way to build a cheap harness at scale, and the page discloses it, which is more than many vendor benchmarks do. But it means the accuracy column answers "how closely does this track two big models" rather than "how often is this right," and on tasks like invoice processing, where a real answer exists in the document, those are not the same question. We have seen this gap before in coding agents scoring 38.8% on private codebases against 95% on the public benchmark.

Both headline multiples are computed against the worst competitor in the set

TypeSafe's homepage advertises "193.6x faster, 444.6x cheaper." The full results table shows where those come from.

The 193.6x speed multiple lands on Sonnet 5 at 78.1 seconds. The 444.6x cost multiple lands on Opus 5 at $0.1761. Those are the slowest and the most expensive entries in the table. Measured against Terra, the fastest competitor at 10.1 seconds, Jev is about 25x faster, not 194x. The headline numbers are arithmetic against worst case, which is standard launch-post practice and worth doing yourself before you build a business case.

The honest comparison is still strong. Terra scores 67.9% and Jev scores 67.8%, a gap of one tenth of a point, and Jev gets there about 76x cheaper and 25x faster. That is a genuinely good trade, and it does not need the 444x framing. What the table also shows is that Jev is not the accuracy leader: Sol at 74.1% and Opus 5 at 73.1% both beat it by more than five points, so anything where correctness dominates cost is not Jev's job.

The variance across tasks is wider than the averages suggest

Jev's per-task scores range from 61.7% on Security Incidents and 61.8% on Invoice Processing up to 76.0% on Customer Service, with Agent Trace Observability at 71.6%. That 14-point spread matters more than the 67.8% average, because it says the model is much better at bounded classification than at extraction from messy documents. Customer service routing into a handful of known buckets is the shape it was built for. Pulling correct line items off an invoice is not, and 61.8% is not a number you put behind an accounts-payable workflow without a human in the loop.

Impact on Creators

The immediate caveat is access: Jev is early-access waitlist only, so nobody outside the program can reproduce any of this yet, and every figure above is the vendor's own, with no third-party verification. That alone should keep it off your critical path this quarter. The documentation and a Python adapter are public if you want to read the interface before applying.

Where this is worth attention is the routing layer inside creative pipelines, which is quietly full of LLM calls doing work no LLM is needed for. Deciding which of five ComfyUI graphs a job belongs to, classifying an inbound asset by type, scoring whether a generation passed a quality bar, picking which of three voices fits a script: these are typed decisions wearing a chat interface, and today they are billed at frontier-model prices and frontier-model latency. A model that answers in 0.4 seconds at $0.0004 changes what you can afford to put in a loop, and loops are where creative automation actually lives.

The discipline is to match the tool to the failure cost. Use a decision model where a wrong answer is cheap and recoverable, such as routing, tagging, triage, and pre-filtering. Keep a frontier model where a wrong answer is expensive, such as anything that writes, edits, or ships without review. And treat the 61.8% invoice figure as the honest floor rather than the 76.0% customer service one, because your messiest task sets your real experience. The same lesson ran through Qwen3-TTS ranking second and twenty-eighth on the same leaderboard, where the number you get depends on which configuration you actually run.

Key Takeaways

• 0% hallucination is a schema-conformance guarantee, not an accuracy claim. Jev cannot emit an invalid type, and it is still wrong about 32% of the time on the vendor's own harness.
• The benchmark's answer key is an average of GPT-6 Astra and Claude Fable 5.1 at high thinking, so the accuracy column measures agreement with frontier models rather than correctness.
• The advertised 193.6x and 444.6x multiples are computed against Sonnet 5 and Opus 5, the slowest and priciest models in the table. Against the fastest competitor, Terra, the speed gap is about 25x.
• The defensible pitch is Terra-level accuracy, 67.8% against 67.9%, at roughly 76x less cost and 25x less latency. Sol and Opus 5 still lead on accuracy by more than five points.
• Per-task scores swing from 61.7% to 76.0%. Bounded classification is the strong case; document extraction is not.
• Early access only, no independent verification, no reproduction possible outside the waitlist.

What to Watch

The number that will settle this is a reproduction nobody at TypeSafe ran. The moment developers off the waitlist can post their own latency and accuracy on their own tasks, the 40x to 200x range collapses to whatever it actually is on real traffic, and the per-task spread is the reason to expect that number to be task-specific rather than a single multiple. Watch for a harness with human-labeled references too, because until one exists the accuracy column is a similarity score against two frontier models and cannot be read as correctness.

The broader thing to track is whether "the model that only talks to code" becomes a category or stays a single product. If it is a category, the frontier labs will ship cheap structured-decision endpoints of their own within two quarters, since they already hold the distribution and the routing traffic, and the interesting question becomes whether a purpose-built architecture holds a real advantage over a distilled small model behind the same typed interface. The gap between the weights you can download and the model on the leaderboard is the pattern to keep in mind here: the interface a vendor advertises and the system you actually run are rarely the same thing, and the only number that ends up mattering is the one you measure yourself.

Frequently Asked Questions

Can Jev really not hallucinate?

It cannot produce output that violates its schema, which eliminates malformed responses, invented fields, and calls to tools that do not exist. It can still return a confidently wrong value inside a valid structure, and on TypeSafe's own evals it does so about 32% of the time.

What does Jev actually cost?

$0.042 per million input tokens, with output tokens free because the outputs are small structured decisions rather than prose. On the four-task eval harness that worked out to $0.0004 per run. The Doom demo ran about $7 per hour at roughly 10 calls per second.

Is Jev more accurate than GPT or Claude?

No. On TypeSafe's own harness Jev scores 67.8%, essentially tied with Terra at 67.9% and Sonnet 5 at 67.8%, while Sol reaches 74.1% and Opus 5 reaches 73.1%. Jev's advantage is cost and latency, not accuracy.

Can Jev write code or text?

No. It returns typed probabilistic decisions only. It cannot generate prose, write code, or explain its reasoning, which is a deliberate design constraint rather than a limitation to be fixed later.

Can I use Jev today?

Not unless you are accepted into the early-access program. TypeSafe is bringing developers off a waitlist, and no independent party has yet reproduced the published speed or accuracy figures.

What should I use it for if I get access?

Bounded classification and routing inside automated loops, where a wrong answer is cheap to recover from. Its weakest published scores are on document extraction at 61.8%, so keep it away from anything where an unreviewed extraction error is costly.