Jev: System One models for Prod, not God — with Diogo Almeida, CEO, TypeSafe AI

Full analysis

A new AI company called TypeSafe AI, run by Diogo Almeida, launched a model called Jev that is built for software to call, not for people to chat with. Almeida co-wrote the InstructGPT paper at OpenAI, the work that made ChatGPT possible, so when he says the whole industry picked the wrong training goal, it lands harder than it would from a random founder. His pitch: models tuned to please humans get overconfident and unreliable, which is fine for a chatbot and poison for code that has to trust the answer.

Here's what's actually being decided for you, the person who buys and builds with AI. Not "should I switch to Jev tomorrow." It's whether you should start splitting your AI work into two buckets: cheap, high-volume decisions that a small fast model handles, and hard reasoning that a frontier model handles. That split is easy to undo. You can test it on one workflow and roll back in an afternoon. There's no deadline forcing your hand. No contract renewal, no shutdown date. So this is a low-stakes experiment, not a bet-the-company move.

The Skeptic

Almeida refuses to publish any benchmarks. He says they're gameable. Convenient, because it means nobody can check his "faster and cheaper while just as smart" claim. That quadrant is empty for a reason. Usually you pay for speed with quality.

The trillion-tokens-a-day number is the one thing he'll show you, and it's the softest kind of proof. A launch video pulled 40 million views. Of course traffic spiked. "Machines call it at night" is a nice line, but free-tier scripts hammering an API at night is not the same as paying production load.

RLCD, his new training method, is unpublished. So the central claim rests on a word nobody outside TypeSafe can inspect.

The Researcher

The mode-collapse argument is real and worth understanding. When you tune a model on human thumbs-up, thumbs-down feedback, it learns to play it safe. It drops the rare, weird answers because those draw obvious penalties. The result is a model that sounds confident even when it shouldn't be. Its stated probabilities stop matching reality. For a chat window, fine. For code that acts on "I'm 90% sure," a lie.

That's a genuine, known problem, and Almeida describing it clearly is not the same as him having solved it. Calibration, meaning the model's confidence actually matches how often it's right, is measurable. He just won't measure it in public.

His three output types, Choice, Score, and Noulli, map cleanly onto a switch statement, a sort, and an if statement. That part is honest engineering.

The Builder

The advice that survives regardless of whether Jev is any good: stop stuffing one giant prompt with ten questions. Break the work into many small yes/no or pick-one questions, each testable on its own. You can do that today with models you already pay for. That's the takeaway worth stealing.

The KV cache point is the practical one. The KV cache is the model's short-term memory of your conversation so far. Today's coding agents like Claude Code and Codex are welded to one model because that memory can't be handed to a different model mid-task. If you want to run twenty cheap parallel checks inside an agent loop, that welding is what stops you. Real constraint, felt by anyone building agents now.

The Open-Source Advocate

Almeida's happiest customers are the open coding agents, the ones not owned by a lab. His bet is that they'll wire Jev in and do things Claude Code and Codex structurally can't, because those two are locked to one model each. That's the interesting wedge. Open agents can mix a cheap decision model with a frontier reasoning model. Closed single-model products can't, without cannibalizing themselves.

But notice: Jev itself is closed. Unpublished method, proprietary weights, no benchmarks. He's arming the open ecosystem with a black box. If TypeSafe raises prices or folds, everyone building on it is stuck. Same lock-in problem, new vendor.

The Compute Pragmatist

"Intelligence per dollar," named after Jevons Paradox, the idea that when something gets cheaper you use way more of it. That framing is right for where the money is going. Nobody's frontier reasoning budget is the problem. It's the millions of small classification and routing calls that add up.

If a small calibrated model can do those cheaply and honestly, you move a lot of volume off expensive models. That's the real prize, and it's testable without believing any of Almeida's philosophy. Route your high-volume decisions to a cheap model, measure whether the answers hold up, keep the frontier model for the hard 5%. People already do this. Jev is one more candidate for the cheap slot.

Where the tension actually is

The Researcher and the Skeptic agree the mode-collapse problem is real but split hard on the fix: is RLCD a genuine third way, or a nice diagnosis with a proprietary label slapped on? You can't settle that, because there's no paper and no benchmark.

The Open-Source Advocate and the Compute Pragmatist both like the two-model split, but the Advocate sees a new lock-in: you'd be leaning on a closed model with zero transparency to power your open agent.

The whole thing hinges on one testable belief: can a cheap model give you honestly-calibrated decisions, meaning when it says 80% it's right about 80% of the time. Everything else is Almeida's story. That one thing you can check yourself.

What to do about it

Don't wait for TypeSafe's marketing. Take one high-volume workflow, the kind where you're currently sending everything to GPT or Claude. Split it: cheap model for the easy calls, frontier model for the hard ones. Measure calibration directly. Log the model's confidence, check how often it's actually right at each level. If the cheap model's confidence tracks reality, you've got real savings and you didn't need Jev to prove it. If it doesn't, you've learned what to demand from any vendor selling "calibrated."

Prediction: TypeSafe AI will not publish an audited or independently reproducible benchmark showing Jev matches frontier models on calibrated accuracy at lower cost before Latent Space's next TypeSafe interview or the next public TypeSafe model release, whichever comes first, through 2027-03-31.

Confidence: Medium. The no-benchmark stance is his explicit, stated strategy, and the silence protects the claim.

Why: Almeida's entire pitch rests on "faster and cheaper while just as smart," a claim that sits in a quadrant everyone else says is empty because speed usually costs quality. He has publicly refused to publish benchmarks, calling them gameable, which is a real argument and also removes the one thing that could disprove him. The trillion-tokens-a-day figure is the only number he offers, and traffic is not accuracy. A company confident its calibration numbers would impress publishes them to win enterprise trust; a company whose numbers are softer than its story keeps selling on vibes and traction through the buying season. The opposite outcome, a voluntary audited benchmark, would cut against his own stated principle and expose the proprietary method he's built the company around, so it's the less likely move.

Revisit by 2027-03-31: We're right if, by then, TypeSafe has released no independently reproducible or third-party-audited benchmark comparing Jev to a named frontier model on calibrated accuracy and cost. We're wrong if TypeSafe publishes such a benchmark that an outside party can reproduce.