A former OpenAI researcher spent two years in stealth building an AI that cannot generate text — and it might be the most useful model ever created for software automation.
On September 15, 2026, a San Francisco startup called TypeSafe AI stepped out of two years of stealth to introduce something genuinely strange: an AI model that will never write you a sentence. It won’t draft an email, explain its reasoning, or even confirm its own name. What it will do is make decisions — fast, typed, probabilistic, and schema-guaranteed — at a speed and price that makes existing large language models look like mainframes.
The model is called Jev, and if the company’s benchmarks hold up under scrutiny, it represents the most significant architectural departure from the LLM paradigm since transformers went mainstream.
The Problem With Chat Models Doing Everything
Diogo Almeida, founder of TypeSafe AI and one of the researchers behind the methods that made ChatGPT useful, has been asking a deceptively simple question for four years: if models have been superhuman at chat for years, where is all the automation?
The answer, he argues, is that the chat interface is the wrong interface for software. When a language model is embedded inside a production system — routing customer tickets, flagging fraud, scoring leads, filtering content — it faces a fundamental mismatch. It was trained to produce human-readable strings. The system consuming its output needs structured data. And somewhere between the model’s token stream and the code that processes it, things go wrong: hallucinated field values, type errors, schema violations, and confidently wrong answers delivered without any signal that the model was uncertain.
“The flexibility of strings also means they might go off the rails,” Almeida writes in TypeSafe’s launch post. “Every frontier model, no matter how smart, still hallucinate and have type errors.”
What Jev Actually Does
Jev is built on what TypeSafe calls the System One Models architecture — a reference to Daniel Kahneman’s fast, intuitive System 1 thinking, as opposed to the slow, deliberate System 2 reasoning that characterizes long chain-of-thought models.
Instead of generating tokens one at a time in an autoregressive sequence, Jev takes unstructured input — a paragraph of text, a blob of structured state, a customer record — and outputs type-safe structured values in a single parallel query. The possible outputs are defined in advance via a schema. The model cannot emit anything outside that schema. Hallucination, in the traditional sense, is mathematically impossible: there is nothing to hallucinate into because the output space is enumerated before the query runs.
Every answer comes paired with a calibrated confidence probability. TypeSafe trained Jev using a new algorithm called Reinforcement Learning for Calibrated Decisions (RLCD), which optimizes not for human preference or verifiable rewards, but for epistemic honesty: a model that says it is 70% confident should be right about 70% of the time. This is a crucial property for automation. If a model can handle 95% of cases reliably but cannot identify which 5% it is uncertain about, it cannot be trusted in an automated pipeline.
The Numbers Are Hard to Ignore
TypeSafe’s performance claims are extraordinary enough to warrant skepticism — and to the company’s credit, they acknowledge this explicitly and lay out the nuance in their launch post.
On their “workflow evals” — a new evaluation methodology designed to measure how well AI performs inside actual code — Jev lands within 3 points of the most expensive frontier models on intelligence benchmarks while running 193 times faster than Claude Sonnet 5 and costing 444 times less than Opus 5 on classification tasks.
The price: $0.042 per million input tokens. Output is free — “too cheap to meter,” in TypeSafe’s phrasing.
The speed: 70 to 500 milliseconds end-to-end. For context, existing frontier LLMs respond in 3 to 329 seconds depending on task complexity and reasoning depth.
The cost comparison is where the math becomes startling. Running frontier-level classification intelligence at roughly $42 per billion tokens — compared to the $200 to $10,000 per billion tokens charged by leading LLM APIs — changes the economics of AI-powered software dramatically. Tasks that were previously too expensive to run on every record in a database become trivially affordable. Applications that required sub-100ms AI responses were simply impossible with existing architectures; Jev makes them routine.
A New Frontier, With Appropriate Caveats
The technical details underlying RLCD — the reward function, architecture specifics, training procedure, and calibration methodology — have not been independently published or peer-reviewed as of launch. TypeSafe has described what the algorithm is designed to do without providing enough information for external researchers to reproduce or audit its behavior. Independent validation will take time.
The workflow evals themselves were designed by TypeSafe’s own team, introducing potential bias even if the content was not deliberately chosen to favor their model. The company uses GPT-6 Astra and Fable 5.1 as reference answers, which may underestimate the relative performance of competing open-source models.
But even discounting these caveats significantly, the demonstrated speed and cost properties are verifiable: Jev’s response times can be measured by any developer with early access, and type-safety is a binary claim that can be falsified with a single counter-example. None has emerged.
What This Means for Software Development
The practical implications are easier to grasp through examples. Consider a fraud detection pipeline that currently batches suspicious transactions for overnight LLM review because real-time LLM inference is too slow and expensive. With Jev, that pipeline runs inline, in under 100 milliseconds, on every transaction, at a fraction of the cost. Consider a content moderation system that today samples 10% of posts because full coverage is cost-prohibitive. With Jev’s pricing, 100% coverage becomes cheaper than current 10% coverage with frontier LLMs.
TypeSafe describes Jev’s use cases as “AI-powered workflows,” “smart if-statements,” and “map-reducing over big data.” The framing is deliberately positioned away from chatbots and copilots and toward the kind of invisible, embedded, always-on intelligence that runs inside production systems at scale.
The company has also demonstrated Jev playing Doom in real time — making 10 queries per second based on structured game state — and completing Wikipedia racing challenges by picking from hundreds of links at each step. These are demos, not production workloads, but they illustrate the latency profile in a visceral way.
The Bigger Picture
TypeSafe’s launch arrives at a moment when the AI industry is reckoning with a persistent gap between the promise of automation and the reality of production deployment. Agents and agentic pipelines have been the dominant narrative of 2026, but the infrastructure supporting them — LLMs producing strings that need to be parsed, validated, and error-handled at every step — has remained fundamentally fragile.
Almeida’s argument is that the interface is the problem, not the model. By building a model that speaks code natively — that outputs typed values, probabilities, and nothing else — TypeSafe is betting that a narrower, faster, cheaper, and more reliable interface will unlock the automation that chat models promised but couldn’t quite deliver.
Whether Jev and the System One Models architecture represent a paradigm shift or a useful but specialized tool will depend on what developers build with early access over the coming months. But for the first time in a while, a new AI announcement is making a claim that isn’t about scale, reasoning length, or benchmark supremacy — it’s about whether the interface itself has been wrong all along.
TypeSafe AI’s Jev is available in early access at typesafe.ai. Workflow evaluation details are published at evals.typesafe.ai.
