He Helped Build ChatGPT. Now He Says Chat Was the Wrong Bet. | Edition 333
Edition 333 — TypeSafe's Jev skips chat entirely — typed, confidence-scored decisions in under a second, now open for early access.
Diogo Almeida helped build the technology behind ChatGPT. At OpenAI, he worked on the instruction-following methods — the research that turned language models from text predictors into something that could actually talk to people. For a while, he thought that work would lead straight to AGI.
On September 15, he launched a company built on the opposite bet. “It became obvious to me that there was something really big missing,” he wrote in TypeSafe AI’s launch post. His new model, Jev, doesn’t chat. It doesn’t write code. It doesn’t explain its reasoning. Ask it a question and it won’t say a word back — it returns a typed answer with a number attached, in well under a second, and that’s the entire point.
The launch spent all of Tuesday at the top of Hacker News, ahead of two other major AI announcements that same day. The pitch: most AI running inside software doesn’t need a paragraph. It needs an answer.
What RLCD actually is
Every major AI lab trains its models against some kind of reward signal. RLHF (reinforcement learning from human feedback) rewards a model for writing things human raters prefer — it’s why ChatGPT and Claude sound helpful and polite. RLVR (reinforcement learning from verifiable rewards) rewards a model for getting a checkable answer right, like a math proof or a passing test. Almeida’s argument is that neither one optimizes for the thing software actually needs from AI: knowing how sure to be.
RLCD — Reinforcement Learning for Calibrated Decisions — trains Jev to attach an honest probability to every answer. If Jev says it’s 80% confident, TypeSafe wants that to be right roughly 8 times in 10, not “sounds confident” dressed up as a number. A genuinely calibrated model can hand off the cases it’s actually unsure about to a human, instead of guessing every time with the same false confidence. That’s a real, previously underserved research gap — most frontier labs still optimize for “reads as correct,” not “knows when it might not be.”
The trade: no strings, no chat, no code
Feed Jev a block of text — a support ticket, a log line, a sentence describing game state — plus a list of typed questions, and it answers all of them in one parallel pass instead of writing token by token. A choice from a list you supply. A score on a scale. A yes/no with a probability. Nothing else comes back — no explanation, no prose, no code. TypeSafe calls this a “System One Model,” borrowing Daniel Kahneman’s term for fast, intuitive thinking, positioned alongside the slower “System Two” reasoning of a full chat model.
Giving up strings is what buys the speed. TypeSafe’s own numbers put end-to-end response time at 70–500 milliseconds, against 3–329 seconds for a typical frontier model call, and claim a 40–200x speed range and up to roughly 444x lower cost on its own benchmark workflows — input tokens at $0.042 per million, output free. All of that is TypeSafe’s own reporting, on its own benchmark suite, comparing itself to itself. TypeSafe says as much outright: “We can’t prove it isn’t subsidized,” and it flags that its reference answers for those benchmarks come from averaging GPT-6 Astra and Claude Fable 5.1, “which biases answers towards OpenAI and Anthropic’s models.”
What it’s actually good for — and not
Because the output space is fixed in advance, Jev genuinely can’t return something outside the schema you gave it. TypeSafe calls this “zero hallucinations,” and that’s true in the narrow sense that it can’t invent a fourth category when you gave it three. It can still pick the wrong one of those three, confidently. Hacker News’s read on launch day was blunt: a bounded model can still be confidently incorrect, and calling something that can’t write a sentence a “frontier model” borrows credibility it hasn’t demonstrated on the tasks that word usually means.
The realistic use case, echoed across early hands-on write-ups, is pairing it with a full LLM rather than replacing one. Jev does the high-volume triage — sort tickets, flag a risky agent action before it fires, score which of 500 leads to call first, check whether a model’s own output stayed inside the rules — and hands anything genuinely uncertain up to a slower, more capable model or a person. Think fast pre-filter sitting in front of the model doing your actual writing and reasoning, not a replacement for it.
What you can actually do with it today
Nothing yet, beyond joining the line. Jev is closed-weight, hosted-only, and gated behind an early-access waitlist at typesafe.ai — no self-hosting, no published architecture paper, and its public GitHub adapter repository held a single commit and a README as of launch day. TypeSafe hasn’t given a timeline for either wider access or open weights.
| Typical frontier LLM | TypeSafe's Jev | |
|---|---|---|
| Optimized with | RLHF or RLVR | RLCD (Reinforcement Learning for Calibrated Decisions) |
| Output | Generated text (strings) | Typed value + confidence score |
| Sampling | Sequential, token-by-token | Parallel, single pass |
| Input price | $0.20–$10 per million tokens | $0.042 per million tokens* |
| End-to-end speed | 3–329 seconds | 70–500 milliseconds* |
| Access | Varies by vendor | Closed weights, waitlisted API |
Almeida is making a specific, falsifiable bet: that the industry spent two years assuming AI’s endgame was a better conversation, when a lot of the real dollar value was sitting in cheap, fast, bounded decisions buried inside software nobody talks to. He might be right — the size of the seed round and Tuesday’s Hacker News thread both say plenty of people think it’s worth testing. But “worth testing” and “proven” are different things, and every number in this story so far is the company grading its own homework.