Imagine hiring a translator to answer a yes-or-no question. They think for a moment, then deliver your answer as a three-paragraph essay in a language you have to parse back into “yes.” That is roughly what happens every time an agent pipeline asks a large language model to make a decision. We ask for a bit of judgment and receive prose, then spend compute, latency, and validation code turning that prose back into the bit we wanted.
On September 15, 2026, TypeSafe AI shipped a model built on the premise that this whole arrangement is absurd. It is called Jev, and it cannot write a sentence. What it returns instead are typed probabilistic decisions for software. The person behind it is Diogo Almeida, a former OpenAI researcher who worked on ChatGPT and on reinforcement learning from human feedback, the training technique that made chat models usable in the first place. After roughly two years of quiet work, his argument is blunt: today’s LLMs are structurally inefficient, and text is the reason.
Text as an accidental interface
I want to be precise about what “structurally inefficient” means here, because it is easy to hear it as a performance complaint and miss the architectural claim underneath.
Natural language became the universal interface for AI systems by accident of training data, not by design. Sequence models learned to predict tokens, so tokens became the output type, so every downstream consumer of a model, including other software, had to accept tokens. That worked beautifully for humans reading a chat window. It works far less well for an agent that needs to decide whether to escalate a ticket, whether a transaction looks fraudulent, or which of four tools to call next.
In those cases, the token stream is overhead twice over. Generating it costs compute proportional to length rather than to the difficulty of the decision. Consuming it costs a parsing layer that can fail in ways the model itself never signals. Anyone who has written a retry loop around a JSON-emitting prompt knows this tax intimately.
What typed output actually changes
A typed probabilistic decision is a different contract. The output has a shape known before inference runs, and it carries a distribution rather than a confident-sounding string. Two consequences follow, and they matter more for agent architecture than any benchmark number.
- The parser disappears. If the output type is guaranteed, the entire layer of schema validation, regex extraction, and reprompting collapses. That is not just less code. It is one fewer place where silent failures hide.
- Uncertainty becomes first-class. A language model expresses doubt in words, which downstream code cannot act on. A distribution over typed outcomes can be thresholded, routed, or escalated. Your agent can finally tell the difference between a decision it should make and one it should hand to a human.
That second point is the one I keep circling back to. Most production agent failures I have looked at are not reasoning failures. They are confidence calibration failures wrapped in fluent text. A model that returns probability mass instead of assertions gives the surrounding system something to reason about.
The hallucination claim, read carefully
Coverage of the launch has framed Jev as a model that cannot hallucinate. I would state it more narrowly, because the narrow version is the interesting one. A model constrained to a typed output space cannot invent a value outside that space. It can still be wrong. It can still assign high probability to the wrong branch. What it cannot do is fabricate a citation, a field name, or an API that does not exist, because those are text phenomena and the output is not text.
So the failure mode changes character. Instead of plausible fiction, you get miscalibration, which is measurable, monitorable, and correctable with the tools statisticians have used for decades. Trading an unbounded failure surface for a bounded one is exactly the kind of move that makes systems deployable.
What this means for how we build agents
The mental model I would encourage is not “Jev replaces your LLM.” It is that agent systems have been running one model class for two distinct jobs. Language generation and decision-making got fused because a single architecture happened to do both passably. Separating them gives you a text model where text is the product and a decision model where decisions are the product.
TypeSafe AI claims Jev is faster and more efficient than previous models, which is what you would expect if the model is no longer paying for tokens it does not need to emit. The developer enthusiasm around the launch reads to me less like excitement about a new frontier system and more like relief. People who ship agents have been building the missing decision layer by hand, in glue code, for two years.
The open questions are the ones that always follow a specialized architecture. How expressive is the type system in practice, how well does calibration hold under distribution shift, and how much of real agent work reduces to decisions that can be typed in advance. Those are empirical, and they will get answered by people running this in production rather than by launch-week commentary.
What already seems settled is the framing. Asking a model to speak in order to decide was never a requirement. It was a habit.
🕒 Published: