Jev Doesn’t Hallucinate. It Decides Wrong.

Diogo Almeida co-invented RLHF. If you’ve argued with Claude or been impressed by ChatGPT or watched GPT-4 navigate a legal brief, you’ve been downstream of his work. Yesterday, he published a blog post announcing Jev — TypeSafe AI’s first model — to Hacker News. It landed at 1,420 points. The headline claim: the model “can’t hallucinate.” Three paragraphs in, in smaller text: the 0% hallucination rate is “not empirical.”

That gap is the story.

What TypeSafe Actually Built

Standard LLMs generate text. Token by token, sequentially, from a probability distribution over the vocabulary. When you ask an LLM to classify a support ticket or route a customer request, you get back prose — something like “This appears to be a billing inquiry, priority high” — and then your system has to parse that string, validate it against expected values, and hope the model didn’t invent a new category. The integration failures are well-documented: malformed JSON, invented fields, confidence-free outputs that leave downstream code guessing.

TypeSafe’s premise is that this is the wrong architecture for automation. Jev doesn’t generate text. It outputs typed values through three primitives: Choice (select from a declared set of options with calibrated probabilities), Score (an ordered level evaluation), and Noul (binary). Every output carries confidence scores. The model generates all outputs in parallel — a single query rather than token-by-token sampling — which is how it achieves end-to-end response times of 70ms to 500ms, compared to the 3 to 329 seconds TypeSafe measured for frontier LLMs on comparable automation workflows. The pricing is $0.042 per million input tokens, with output tokens free.

The training method is called RLCD — Reinforcement Learning for Calibrated Decisions — distinct from the RLHF that Almeida helped develop at OpenAI. The distinction is architecturally significant. Standard constrained decoding frameworks like Outlines or XGrammar take an existing general LLM and apply grammar masks at inference time, forcing outputs to conform to a schema. A March 2026 paper from Amazon and UPenn identified a serious problem with this approach: the masking process distorts probability distributions, pushing the model toward structurally valid but semantically incorrect outputs. The researchers call it the “projection tax.” On GSM8K with a 1B model, naive grammar-constrained decoding degraded accuracy enough that recovering from it improved performance by 24 percentage points. TypeSafe’s claim is that RLCD avoids this by training a model from scratch to produce typed output, rather than constraining an existing LLM’s text generation. That’s a legitimate response to a real problem in the constrained-output field.

TypeSafe was founded by Almeida alongside Erik Gafni and Sasha Sheng. The company operated in stealth for two years before yesterday’s launch. Jev is in early access; no production API documentation was available at the time of writing, and the model’s architecture remains proprietary — a notable gap given that independent validation of the RLCD calibration claims depends on evaluators being able to probe the system systematically.

DCVC led a $40 million seed round at launch. James Hardiman at DCVC framed the investment around “one of the biggest remaining challenges in AI: turning increasingly capable models into technology that developers can reliably build into products at scale.” That’s an infrastructure bet, not an application bet. Almeida’s own framing is starker: “most intelligence should eventually live inside software, running quietly in the background.”

The Hallucination Claim Doesn’t Hold

TypeSafe’s post claims a “0% hallucination rate.” The same post notes this is “not empirical.” Both sentences are technically defensible, and together they’re more honest than the headline.

What Jev actually guarantees is this: the output will conform to the schema you declared. If you asked for a Choice between [“high_priority”, “medium_priority”, “low_priority”], Jev returns one of those three strings. It will not invent “urgent_priority.” It will not return null. It will not return a float. That removes a genuine class of integration failures — the ones that break production pipelines because the LLM phrased its answer differently than the parser expected.

But Jev can still decide “high_priority” when “low_priority” is correct. It can return that wrong answer with a confidence score of, say, 0.92. The confidence score — which is supposed to be calibrated — can itself be wrong in ways that are hard to detect without ground-truth labels. TypeSafe’s RLCD training is specifically designed to produce calibrated probabilities, and their Doom demo — querying structured game state 10 times per second, at roughly $7/hour — is genuine evidence the approach works at inference speed. But calibration is not the same thing as accuracy. A well-calibrated model tells you how confident it is; it does not tell you whether the answer is right.

The team’s own benchmark data makes this visible. On invoice processing — a structured, well-defined domain — Jev achieved 61.8% accuracy against an LLM baseline of 79.1%. TypeSafe’s post includes this number without removing it. It shows up because invoice processing requires reasoning across line items, applying business rules, and handling exceptions — tasks where constrained output format doesn’t compensate for weaker reasoning. When decision complexity increases beyond classification into judgment, typed outputs don’t help because the problem isn’t formatting. The wrong answer in a typed field is still the wrong answer.

As Anthony Maio noted in an independent technical analysis published the same day: “The model can still pick the wrong option, misread the evidence, or assign an unjustifiably high probability to a bad answer.” Type-safety constrains output shape. It does not constrain judgment quality. The hallucination claim misleads builders into trusting Jev’s confidence scores the way they’d trust a database constraint — a category error that will cause real failures in production.

There is also a composition problem. TypeSafe demonstrates multi-step workflows where multiple Jev queries chain into each other. Individual confidence scores don’t automatically produce calibrated final confidence when composed through a pipeline. A, say, 92% confident classification feeding an 88% confident routing decision doesn’t yield the naïvely-expected 81%-confident outcome; it yields an outcome whose actual reliability depends on the specific error correlations between both steps, which neither Jev nor the pipeline framework can report. For automation where errors compound silently through a pipeline, this is where the confidence score becomes a liability rather than a safeguard.

Where the Thesis Is Right

Strip the marketing and Almeida’s architectural claim is worth taking seriously. The text-in, text-out paradigm made sense for consumer interfaces — humans expect prose. For software automation, where the downstream consumer is code, not a person, it’s architecturally wrong. When a pipeline needs a routing decision 10 times per second, you don’t want token-by-token sampling from a frontier model; you want a fast, typed, probabilistically calibrated response your system can act on directly, at a cost that makes high-throughput workloads viable.

The “System One” branding TypeSafe uses isn’t just clever. It accurately identifies what the model is optimized for. Kahneman’s System 1 is fast, parallel, and suited to well-structured problems. Expecting it to perform System 2 reasoning is the mistake. High-throughput classification, real-time routing, scoring large datasets where the schema is stable and the judgment is well-defined — these map exactly onto Jev’s primitives. For these tasks, Jev at $0.042/MTok and 70–500ms round-trip is the right tool. An LLM doing the same routing at frontier model pricing is 40 to 200 times more expensive and runs 40 to 200 times slower. The cost difference doesn’t just affect margins; it determines whether high-throughput automated judgment is economically viable at all.

The $40 million raise is legible in this context. If Jev becomes the typed decision layer that sits between events and LLM calls in AI-native software — routing before the expensive reasoning model gets involved, classifying at pipeline entry, scoring at volume — it doesn’t need to reason at all. It needs to be fast, reliable, and cheap at scale. Whether RLCD actually produces better calibration than fine-tuning an open-weight model with constrained output heads is an open empirical question that TypeSafe hasn’t yet answered with independent benchmarks. One HN commenter reported building a working approximation in two hours with an open-weight model. TypeSafe’s evaluation was conducted by their own “model capabilities team,” with benchmark comparisons against models in non-reasoning modes. The $40 million and the 1,420 Hacker News points are evidence the thesis is worth taking seriously. They’re not evidence the model is what the marketing says it is.

The man who helped make LLMs good at instructions is now arguing that instruction-following is the wrong interface for most software intelligence. There are structural reasons to think that’s true, and $40 million in seed funding says DCVC agrees. The “zero hallucination” claim is where the credibility risk concentrates — not because Jev generates fiction, but because it generates wrong answers that look like facts. A JSON field set to the wrong value with a high confidence score is more dangerous than a hallucinated paragraph, because the paragraph gives you text you can read and question. Jev’s output passes silently into the next step of your pipeline. That confidence score is the part to watch, not because it’s a lie, but because it’s what confident, wrong, automated routing looks like.

AI-generated editorial illustration · TemperatureZero · September 16, 2026