Models have been superhuman at chat for years, and the industry still can't point to where all the automation went.

Diogo Almeida, who helped build the instruction-following research that became ChatGPT, spent four years on that question before he left OpenAI. His answer, shipped in September 2026 as TypeSafe AI's Jev, is that the bottleneck was never raw intelligence. It's the interface. A model that replies in prose is an awkward component to build software on, because software doesn't consume sentences. It consumes values.

The class TypeSafe calls System One is named after the fast, intuitive thinking in Kahneman's Thinking, Fast and Slow. A System One model takes unstructured state in and returns typed probabilistic decisions out, with no chat interface and no string generation. Using a general-purpose generative model in that role wastes tokens and processing time at scale.

Strings are the wrong interface for software

Every pipeline I've built has the same point of friction: somewhere a language model writes prose and my code reads it back. The application wants a decision about keeping or deleting an email, or classifying a ticket as escalation. A frontier model generates a full paragraph containing the reasoning and the one-word decision, and the response gets routed through a parser to extract that word.

The waste shows up in four places at once. Output tokens cost three to eight times the input price on most providers, and a classification answer is mostly output. The response is a string, so it has to be parsed, and JSON mode wraps the real answer in a structure that can multiply the token count five to ten times on a small task like email classification. The value then needs validation against a schema, because a generative model can emit a response you never defined. And when any of that fails, retry blocks cost another full generation. A task whose substance is a single yes or no bills like a small essay.

There's a fifth cost that doesn't show on the invoice. A generative model is systematically overconfident. Ask for a confidence score and you get one, but the number isn't calibrated, so you can't branch on it. A model that's right 95% of the time and can't tell you which calls are in the other 5% can't run unattended. You keep a human in the loop because you have no way to know when the model needs one.

The agent loop makes this worse, because an agent makes a decision at every step. Every decision is another model call, and the loop slows down on retries and unverifiable responses.

What a System One model actually is

Jev gives up string generation entirely. You declare the shape of the answer up front and call it like a function: send a state and a set of questions, and get the fields back filled in, each with a calibrated probability attached. TypeSafe describes it as a frontier-intelligence function call.

Parallel sampling. A chat model builds its answer one token at a time, each conditioned on the last. Jev fills every field in a single pass. TypeSafe reports end-to-end response times of 70 to 500 milliseconds against 3 to 329 seconds for frontier models, and you can ask several questions about the same state in one request without meaningfully changing the response time. That's where the 40x to 200x speed claims come from.

Schema conformance by construction. The possible outputs are enumerated before the call, so a wrong model decision cannot produce a type error. TypeSafe's 0% type-error figure is derived from the construction of the responses, not from testing.

Calibrated confidence. Every answer ships with a probability. TypeSafe trains with Reinforcement Learning for Calibrated Decisions (RLCD) instead of RLHF, so those probability numbers are genuinely accurate: if the confidence is high, the accuracy is high. That predictability is what makes the model composable into systems that run unattended.

The question types map onto what software actually asks. A Noul answers yes or no and returns the probability the statement is true. A Choice picks from a set of up to 255 options and returns a probability per option plus an overall confidence. A Score rates the input against ordered levels like low, medium, high. Keep or drop, route to tier two or tier three, is this urgent. Each question maps to a line of code that returns a typed value.

The token economy of a decision

The pricing is the other half of the story. Jev costs $0.042 per million input tokens, and output is free, because there is no output in the billing sense. TypeSafe advertises it as 238 times cheaper on input than Claude Fable 5.1's $10 per million. A frontier chat model lists around $5 per million input and $25 to $30 per million output, and output is exactly where a classification answer lives.

Small numbers hide the story. Volume exposes it. Here's the cost function:

def cost_per_call(input_tokens, output_tokens, in_price_mtok, out_price_mtok): """Dollars for one call from token counts and per-million-token prices.""" return (input_tokens * in_price_mtok + output_tokens * out_price_mtok) / 1_000_000 # A frontier chat model on a keep/drop decision: 600 in, 80 out. llm = cost_per_call(600, 80, 5.00, 30.00) # $0.005400 # Jev: same 600 input tokens, no output charge. jev = cost_per_call(600, 0, 0.042, 0.0) # $0.000025 print(f"generative LLM: ${llm:.6f} per call") # $0.005400 print(f"System One: ${jev:.6f} per call") # $0.000025 print(f"ratio: {llm / jev:.0f}x") # ~214x 

Run that at a million decisions a day and the difference stops being trivia. The generative model bills about $5,400 for that volume. Jev bills about $25. Third-party measurements land between the extremes: one group measured 1,000 eight-way routing decisions at $0.015 on Jev against $0.61 on GPT-5.6 Terra, about 40x. TypeSafe's own workflow evals claim 444.6x cheaper, and LangChain repeats 400x lower cost on classification tasks. Whatever the honest middle is, it's two orders of magnitude, and it's structural, not a price war.

The gap isn't because Jev is a smaller model that happens to be good enough. It's because a generative model bills you for the process of producing prose, and a decision doesn't need prose. Output tokens, parsing, validation, retries, and the uncertainty tax all disappear together because the model was built not to generate strings in the first place.

The instinct when you see that ratio is to reach for a cheaper generative model instead. That isn't the fix. A smaller generative model still produces a string, still needs parsing and validation, and still reports confidence you can't trust. It lowers the price per call and leaves the structural waste exactly where it was. The waste is in the interface, not the invoice.

A classification call, two ways

Same routing decision, two implementations. First, the generative approach that most early pipelines used:

import json def route_ticket_llm(ticket, client): """Ask a chat model to route a support ticket. Returns (tier, confidence).""" prompt = ( "Classify this support ticket into one of: urgent, standard, low. " 'Return JSON: {"tier": "...", "confidence": 0.0-1.0}\n' f"Ticket: {ticket}" ) raw = client.chat.completions.create( model="gpt-5.6-terra", response_format={"type": "json_object"}, messages=[{"role": "user", "content": prompt}], ).choices[0].message.content parsed = json.loads(raw) # can raise tier = parsed["tier"] # can be anything confidence = float(parsed["confidence"]) # can be nonsense if tier not in {"urgent", "standard", "low"}: tier = "standard" # a guess on the failure path return tier, confidence 

Now the System One version, using the TypeSafe SDK shape:

from typesafe_sdk import Choice, TypeSafeClient client = TypeSafeClient(api_key="...") def route_ticket_jev(ticket): """Same decision. Typed from the start, one parallel pass.""" res = client.system_one( questions={ "tier": Choice( instructions="route the ticket", criteria={ "urgent": "revenue lost or service down", "standard": "needs a person today", "low": "can wait", }, ), }, model="jev-1.13.0", state={"ticket": ticket}, ) choice = res.choices["tier"] return choice.choice, choice.confidence 

The second version has no parse step, no validation step, and no failure path where the model returns a value you didn't allow. The schema was part of the request, so the contract is enforced before the call rather than after it.

The difference that matters most is what happens with an ambiguous ticket. In the first version, confidence is a string the model made up. In the second, it's a number you can trust enough to branch on:

tier, confidence = route_ticket_jev(ticket) if confidence < 0.7: tier = escalate_to_human(ticket) # Jev says it's not sure. Trust that. 

That branch is the whole automation argument in one line. When the model can tell you it's uncertain, you route the uncertain cases to a human and let the confident ones run unattended. The model doesn't need to be right every time. It needs to be honest about when it isn't, and the system around it becomes reliable even though the model isn't.

This isn't hypothetical for me. My own news filter uses a small Jev call to decide keep or drop before spending a full LLM on anything worth reading. A logged run came back at 354 input tokens and a probability, total. The expensive model never sees the boring stuff.

The role is specific, and the stack keeps the big model

Nothing here argues against generative models. They're for open-ended reasoning and generation, and nothing replaces them there. The argument is about the division of labor inside an LLM operation: the big model thinks and writes, and the decision points around it run on something shaped like a function call.

The early deployments show the pattern. LangChain's Open SWE router originally classified requests with an LLM using structured output, then switched to Jev and made classification almost 50 times faster. In the A/B test that mattered, routing 973 agent threads across model tiers cut the median cost per thread 64%, from $2.61 to $0.94, with no measurable quality change. The same team ran the opposite experiment, routing everything to the cheapest model, and killed it within a day because engineers said output quality was disrupting their work. Cheapness was never the objective. Fitting the tool to the task was.

The guardrail pattern is the one I expect to spread. Coding harnesses like Claude Code and Cursor already classify dangerous actions before taking them, but the classifier lived in their closed-source code. A cheap, calibrated decision model lets any agent apply the same gate before a tool execution by asking Jev whether the call is risky, and blocking it if the answer is yes. LangChain shipped exactly that as Auto Mode middleware over Jev.

Read the vendor claims with suspicion

None of this requires believing TypeSafe's biggest numbers. The workflow-eval claims of 193.6x faster and 444.6x cheaper come from the vendor's own evaluations, built by its own team, scored against models the vendor chose. The intelligence-parity claim is only about System One shaped tasks, not general capability.

What you can verify yourself is the price, the latency on your own calls, and the schema guarantee, which is falsifiable by a single bad response. Treat the launch numbers as the ceiling, measure your own workload, and expect the real ratio to land somewhere between 40x and 400x. That's still a big number, and it doesn't depend on marketing.

Why "rise" is the right word

The name Jev comes from William Stanley Jevons, the economist who noticed that making steam engines more efficient increased the demand for coal rather than reducing it. Cheaper steam meant more uses for steam. TypeSafe's bet is that machine intelligence follows the same path: every order of magnitude drop in the cost of intelligence unlocks orders of magnitude more use cases. Their own Doom demo runs about ten queries a second, which they estimate costs around seven dollars an hour, and their reaction was that this was cheaper than expected. A few years ago that sentence would not have existed.

The price and the interface put decisions inside ordinary code paths for the first time. The chatbot race never did that. When a routing decision costs a fraction of a cent and answers in a hundred milliseconds, you stop treating AI as a service you call for special occasions and start treating it as an if-statement that happens to be learned. Projects involving decision-making at scale, such as the map-reduce over a petabyte of unstructured data, or the email triage that never sleeps, never made sense at frontier prices with prose responses. They make sense at $0.042 per million input tokens with typed outputs.

Software was never waiting for a model that could write better. It was waiting for a model that could decide, cheaply enough and honestly enough to be trusted with the boring work. The big generative models will keep getting better at thinking and writing. The decisions in between will increasingly be made by models that don't write at all.