Every LLM release for the past three years has promised more reasoning, longer context, or better code. On September 15, 2026, Diogo Almeida — one of the researchers behind the RLHF work that shaped ChatGPT — launched something aimed at a completely different bottleneck: the fact that a chat model is often the slowest and most expensive way to make a small, repeated decision inside a production system.
His new company, TypeSafe AI, calls its first model Jev a "System One Model." It doesn't generate text at all. It takes structured or natural-language input and returns a typed decision — a choice, a score, or a yes/no probability — in one parallel forward pass instead of token-by-token generation. TypeSafe claims 20-200x faster and 40-400x cheaper than LLMs on the same class of task, and the launch immediately drew a 256-comment Hacker News thread that both validated the idea and pushed hard on the marketing.
If you're building AI agent pipelines, routing logic, or structured output workflows today, this is worth fifteen minutes of your attention — not because it replaces your LLM, but because it's a preview of a category that's about to get crowded.
TL;DR: What people are asking
| Question | Direct answer |
|---|---|
| Is Jev an LLM? | No. TypeSafe AI says explicitly it is not a language model — it can't generate strings, only fixed-shape decisions. |
| What can it output? | Three primitives: Choice (pick 1 of up to 255 options), Score (a value on a scale), Noul (a yes/no probability) — each with a confidence value. |
| How fast is it? | 70ms-500ms end-to-end per TypeSafe's benchmarks, versus 3-329 seconds for comparable LLM calls. |
| How much does it cost? | $0.042 per million input tokens ($42/billion); output tokens are free because there's no autoregressive generation to meter. |
| Does it replace GPT or Claude? | No — it has no chat interface, a 32K context window, and no text/code generation. It's positioned to run alongside an LLM, not instead of one. |
| Is "can't hallucinate" literally true? | Only in the narrow sense that it can't emit a malformed answer. It can still be confidently wrong — critics on Hacker News made this distinction loudly and TypeSafe's own CEO agreed with it in the thread. |
| Can I use it today? | It's in early access via a waitlist; there's no public API pricing page or OpenRouter listing yet. |
What a "System One Model" actually is
TypeSafe AI's naming comes from Daniel Kahneman's Thinking, Fast and Slow — System 1 is the fast, intuitive judgment your brain makes without deliberate reasoning; System 2 is slow, effortful analysis. Reasoning models like GPT-5.6 Sol or Claude are built to emulate System 2. Jev is built to be very good, very cheap System 1: the equivalent of a human instantly recognizing "that email is spam" without working through a proof.
Under the hood, Jev takes:
- Input: unstructured text or structured JSON program state (not images, as of this launch).
- A question: framed as one of three primitives —
- Choice: select 1 of up to 255 predefined options, with a probability distribution across all of them.
- Score: return a value on a continuous scale (e.g., churn risk 0-1).
- Noul: a portmanteau of "boolean," returning a calibrated yes/no probability.
- Output: the selected primitive's value, plus a confidence score — computed in parallel, not generated one token at a time.
Because the output space is fixed and enumerated ahead of time, TypeSafe can compute every possible answer's probability in a single forward pass instead of sampling tokens sequentially. That's the source of both the speed and the "output tokens are free" pricing — there's no decoding loop to meter.
TypeSafe's CEO confirmed on Hacker News that this comes from "RLCD" — Reinforcement Learning for Calibrated Decisions — a training method distinct from the RLHF that Almeida helped pioneer at OpenAI, and from the RLVR (Reinforcement Learning with Verifiable Rewards) used to train reasoning models. Where RLHF optimizes for human-preferred text and RLVR optimizes for verifiably correct outputs like passing test cases, RLCD explicitly optimizes for calibration — a model that says "70% confident" should be right about 70% of the time it says that, across the board.
TypeSafe hasn't published an architecture paper. Commenters on Hacker News guessed everything from a stripped-down text diffusion model to an encoder-only transformer with classification heads; TypeSafe has said only that it's "close to the chest for now," with a paper possibly coming later.
The numbers TypeSafe is publishing
| Dimension | Typical LLMs | Jev / System One |
|---|---|---|
| Training objective | RLHF (human preference) or RLVR (verifiable rewards) | RLCD (calibrated decisions) |
| Output | Free-form strings — text, code, refusals, or type-safe values after parsing | Typed values from a fixed set: Choice, Score, Noul |
| Sampling | Sequential, one token conditioned on the last | Parallel — all primitives computed in one pass |
| Input cost | $0.20-$10 / million tokens | $0.042 / million tokens |
| Output cost | Often ~5x the input price | Free (no decode loop to bill for) |
| Latency | 3-329 seconds for frontier models | 70ms-500ms |
| Confidence | Inconsistent unless explicitly and imperfectly prompted for it | A calibrated probability attached to every answer, by design |
| Context window | Frontier models: hundreds of thousands of tokens | 32K, per early users |
| Multimodality | Text, images, sometimes audio/video | Text and structured JSON only, no images yet |
TypeSafe built its own "workflow evals" for this launch rather than running public benchmarks, comparing Jev against the average prediction of GPT-6 Astra and Fable 5.1 on multi-step decision graphs. In that internal eval, they report Jev "off the charts" on the cost/speed Pareto frontier — but several Hacker News commenters flagged that comparing against an average of two models (rather than ground truth) is an unusual choice, and one plotted result showed Jev's raw accuracy below Sonnet 5's on the specific chart shared. TypeSafe has said it deliberately skipped public benchmark leaderboards and will publish only one-off evals tied to future product updates — a decision some in the thread read as convenient, since a bad public benchmark score would undercut the "frontier" framing.
What Hacker News actually pushed back on
This is the part worth reading carefully if you're deciding whether to put Jev on a roadmap. The top-voted critique wasn't about the tech being fake — several commenters, including engineers who said they'd use it in production, thought the underlying idea was genuinely good. The pushback was about the framing:
"Frontier model" is doing a lot of work. Jev can't write code, hold a conversation, or generate a sentence. Calling it a frontier model in the same sentence as GPT or Claude, several commenters argued, borrows credibility it hasn't independently earned — one suggested a more honest headline would be "advanced the speed/cost frontier for structured decisions," not "a new frontier model."
"Can't hallucinate" is a narrower claim than it sounds. TypeSafe's launch page shows a 0% hallucination chart, derived from the fact that schema matching is mathematically guaranteed — Jev literally cannot return a value outside its defined output set. But a guaranteed-valid answer can still be a confidently wrong one, the same way a classifier can be certain and incorrect. TypeSafe's own CEO agreed with this distinction directly in the thread: "it's also possible to be confidently wrong (and all future models will be smarter still and still have that possibility)."
The speed comparison may not be apples-to-apples. Several commenters noted that Jev's 70ms figure is compared against LLMs doing full autoregressive generation of an entire structured answer — schema names, formatting, and all — rather than against an LLM constrained purely to emit the equivalent short decision. That's a legitimate methodology question TypeSafe hasn't fully resolved.
The Doom demo relies on a text description of the game, not vision. The widely-shared clip of Jev playing Doom in real time uses structured text state (enemy positions, distances, angles) fed in as JSON, not raw pixels — meaning the model effectively has information a human player wouldn't (seeing through walls, exact coordinates). It's a legitimate demonstration of low-latency decision-making, but not evidence of general game-playing intelligence, and TypeSafe hasn't claimed otherwise once pressed.
None of this means the underlying premise is hollow — it means treat the marketing copy, especially "frontier" and "can't hallucinate," as claims to verify against your own workload rather than facts to repeat.
Where this actually fits: LLM-in-the-loop, not LLM-replacement
The most useful reframing from the Hacker News thread came from a commenter who pointed out that the real choice isn't "Jev vs. Claude" — it's using an LLM interactively to define the decision logic, then running that fixed logic through something like Jev in production, at a fraction of the cost and latency. That's consistent with what TypeSafe itself says: the goal isn't to eat LLM market share so much as to let AI run in the inner loop of software that currently either skips AI entirely or awkwardly bolts an LLM call onto every request.
Concretely, that inner loop shows up in a few recurring shapes:
- Classification and routing at volume. Deciding which support ticket queue a message belongs in, which fraud-review tier a transaction gets, or which agent in a multi-agent system should handle a task — repeated millions of times, where an LLM call is overkill for both cost and latency.
- Guardrails and verification layers. One early-access user described using Jev's Noul primitive as a second verification pass on another model's output — catching low-confidence or contradictory answers before they reach a user. This pairs naturally with an embedded-evaluator-style pattern, just automated and per-request instead of organization-wide.
- Real-time, latency-critical decisions. Anything where a 3-8 second LLM round trip breaks the UX — voice agents deciding whether to interrupt, game NPCs, or UI automation that has to react within a frame budget.
- Map-reduce over large data volumes. Scoring or tagging millions of records where per-call LLM cost would be prohibitive, but a fixed decision schema is workable.
What it's explicitly not good for, by TypeSafe's own admission and Hacker News consensus: open-ended text generation, code generation, long-context reasoning, multi-turn conversation, or any task where the "right" output isn't expressible as a choice from a fixed set, a score, or a boolean. If your tool_use / JSON schema extraction already returns a small enumerated field today, that's the workload Jev is built for. If it returns free text or code, Jev isn't a candidate.
The economics angle: why Jev is named after Jevons
TypeSafe named the model after William Stanley Jevons, the 19th-century economist behind the Jevons paradox: when steam-engine efficiency made coal cheaper to burn, total coal consumption rose, because cheaper energy unlocked new uses that weren't economical before. TypeSafe's bet is that AI decision-making follows the same curve — every order-of-magnitude drop in the cost of a decision doesn't just make existing AI usage cheaper, it makes previously-uneconomical automation viable for the first time.
That framing matters for anyone doing cost optimization on AI spend today. If a $0.042/MTok, sub-second decision model holds up under real-world testing (not just TypeSafe's own workflow evals), it changes the calculus on which decisions are worth automating at all — the same way cheap SMS made two-factor auth ubiquitous, or cheap embeddings made semantic search a commodity feature instead of a research project.
The honest limits, as of this launch
- No public API or pricing page yet — access is by waitlist, with TypeSafe prioritizing "developers off the waitlist as quickly as we can."
- 32K context window, reported by early users — meaningfully smaller than frontier LLM context windows, which limits how much program state you can feed it per decision.
- No image or audio input — text and JSON only, so anything vision-dependent (including a fair version of the Doom demo) is out of scope today.
- No architecture paper or independent benchmark — TypeSafe has said it will skip public leaderboards in favor of its own workflow evals, which limits third-party verification for now.
- Not available through OpenRouter, Bedrock, or any model hub — its request/response shape doesn't match the standard OpenAI-style chat API, so integrating it requires a bespoke client rather than swapping a model string.
FAQ
What is Jev by TypeSafe AI? Jev is TypeSafe AI's first "System One Model," launched September 15, 2026 by founder Diogo Almeida. It returns typed decisions — a choice, score, or yes/no probability — with a calibrated confidence value, instead of generating text.
Is Jev a large language model? No. TypeSafe AI says explicitly that Jev cannot generate strings — it only returns values from three fixed primitives, which is what allows parallel (non-autoregressive) computation.
How much faster and cheaper is Jev than GPT or Claude? TypeSafe claims 20-200x faster (70ms-500ms vs. 3-329 seconds) and 40-400x cheaper ($0.042/MTok input, free output). These are TypeSafe's own published figures; independent third-party verification is still limited as of this writing.
Can Jev really "never hallucinate"? It can't emit a malformed or off-schema answer — that part is mathematically guaranteed. It can still return a schema-valid answer that's factually wrong, a distinction TypeSafe's own CEO acknowledged directly during the Hacker News launch discussion.
Does Jev replace LLMs like GPT-5.6 or Claude? No. It has no chat interface, no image input, a 32K context window, and can't generate text or code. Early users and TypeSafe both describe it as complementary — an LLM defines the decision logic, Jev executes the repeated structured part of it cheaply.
What is RLCD? Reinforcement Learning for Calibrated Decisions — TypeSafe's training method for Jev, explicitly optimizing for well-calibrated probabilities on System One-style tasks rather than for human preference (RLHF) or verifiable rewards (RLVR).
Related reading
- He co-invented ChatGPT. Now he says it was a "weird detour." — a deeper profile of founder Diogo Almeida's case against RLHF, plus his own explainer video
- What is MCP? Model Context Protocol architecture guide
- Structured output and JSON mode prompting: a complete guide
- Structured output with tool_use and JSON schemas
- Scalable oversight: RLHF, DPO, Constitutional AI explained
- What is an embedded evaluator in AI safety?
- Agency: AI agents as specialists, a complete guide
- How enterprises use OpenRouter for model routing and cost optimization
- Official: TypeSafe AI launch post · TypeSafe AI docs
Figures, claims, and product details in this piece reflect TypeSafe AI's September 15, 2026 launch materials and the public Hacker News discussion that followed. Jev remains in early access; pricing, context limits, and benchmark comparisons may change as the product moves toward general availability.