Every model I use in production was optimised for a reader. RLHF rewards answers a person enjoys reading, so the output arrives as prose: fluent, hedged, shaped like an explanation. That is the right shape when a human is on the other end.
It is the wrong shape when the consumer is a switch statement.
Most of the AI actually running in my products is not answering a question. It is deciding. Route this ticket. Flag this transaction. Is this AIS position plausible. Which of sixty vessel types is this. In every one of those cases I take a model built to talk, force JSON out of it with a schema, parse the result, validate it, retry when it drifts, and call the whole arrangement an integration.
Typesafe, an AI lab founded by former OpenAI researcher Diogo Almeida, released Jev in early access this month. It is the first of what they call System One models, and it does not generate text at all.
System One and System Two
The name borrows Kahneman. System Two is slow, deliberate, sequential reasoning: the chain of thought, the long plan, the essay. That is what frontier LLMs are built for and it is genuinely hard work.
System One is the fast automatic judgement. Is this email spam. Does this clause mention termination. A human does that in a fraction of a second without narrating it. We have been paying System Two prices for System One answers and then throwing the narration away.
Jev drops autoregression for parallel sampling and is trained with a method Typesafe calls Reinforcement Learning for Calibrated Decisions. Three consequences matter to anyone wiring this into software.
Type errors become impossible. The model selects a value inside the schema rather than emitting characters that hopefully parse. There is no malformed JSON failure mode because no JSON is being written, and no invented enum member because the enum is the output space.
Confidence becomes a number you can threshold. Every decision ships with a calibrated score, where higher confidence genuinely predicts higher accuracy. Ask an LLM how sure it is and you get a number shaped like confidence rather than one that tracks correctness.
Latency lands inside the UI budget. Typesafe reports 70ms to 500ms per call, which puts a decision in a request handler or a keystroke handler instead of a background job.
The numbers, and who is claiming them
These are vendor figures from the launch post and the company evals. Nobody independent has reproduced them yet.
| Dimension | Frontier LLM | Jev |
|---|---|---|
| Latency | Seconds on comparable tasks | 70ms to 500ms |
| Input cost | $0.20 to $10 per million tokens | $0.042 per million tokens |
| Output cost | Roughly 5x the input rate | Free |
| Output shape | String you parse and validate | Typed value |
| Confidence | Self-reported, miscalibrated | Calibrated per decision |
On their workflow evals, benchmarked against GPT-6 Astra and Fable 5.1, Typesafe says Jev holds the Pareto frontier by close to two orders of magnitude, with headline figures of roughly 194x faster and 445x cheaper. The demos are the fun part: a Doom bot issuing ten queries a second for about seven dollars an hour, and a WikiRacing agent choosing between up to 255 options per step.
Free output is not a marketing trick
It reads as absurd until you look at what an output is. A chat model bills output tokens because it generates them one at a time, each costing a full forward pass. Jev is not composing a sequence. It is selecting from a bounded set the schema already defined, so the work is dominated by reading the input.
Pricing follows architecture. Once the output is a choice rather than a composition, the cost collapses to what it took to understand the question.
Where it fits in a stack I already have
The mistake would be reading this as an LLM replacement. It is not one. It is the piece that belongs everywhere I am currently using a large model badly.
// Today: one LLM call, a string, a parse, a retry, a prayer.
const raw = await llm.complete(`Classify this ticket as JSON: ${body}`);
const parsed = JSON.parse(raw); // can throw
const team = parsed.team ?? 'general'; // can be a team that does not exist
// System One shape: the type is the contract, not the prompt.
const { value, confidence } = await decide({
input: body,
schema: { team: ['billing', 'auth', 'shipping', 'general'] },
});
if (confidence < 0.85) return escalateToHuman(body);
return routeTo(value.team);
That second version is illustrative rather than the real SDK surface, but the shape is the point: no parse step, no fallback for an invented team name, and an escalation path driven by a number that means something.
Four places the pattern earns its keep:
| Use | Why it changes |
|---|---|
| Conditional logic in workflows | Every branch currently string-matching an LLM's yes or no |
| Map-reduce over large datasets | Classifying a million rows is a pricing problem before it is an intelligence problem |
| Real-time paths | Anything answering inside a request or a game loop, where a two-second call was never viable |
| Guardrails over an LLM | Let the big model write, then verify the claim cheaply enough to run on every response |
What it gives up
It cannot write. No prose, no code generation, no summaries, no open-ended reasoning, and no explanation of why it decided what it decided. If the answer is a sentence, this is the wrong model and it is not close.
In exchange, hallucination becomes structurally impossible within the type, confidence becomes actionable, and latency and cost drop far enough to put a decision where you would never previously have put a model call.
That trade is the interesting part. Almost every other lab is racing to make one model do everything. This one deliberately removed the headline capability to make the remaining one reliable.
What I would actually do next
The work I do is full of System One decisions hiding in plain sight. Vessel type classification. Whether a port call document mentions a hazardous cargo class. Whether an AIS track is plausible or spoofed. Each is a typed decision over a bounded set, repeated across millions of rows, currently either hand-coded as brittle rules or handed to a model too expensive to run at that volume.
I would not rebuild anything around an early access model from a new lab. I would take one classification job already running on a frontier model, run both in shadow for a week, and compare accuracy at equal confidence thresholds. Cheap experiment, unambiguous answer.