Jev Skips the Chat: Decisions With Confidence Scores, 200x Faster

A new model class answers structured questions in parallel and returns typed outputs with probabilities instead of text. The speed and price claims are extreme. The idea underneath them deserves your attention regardless.

A post crossed my feed this week with numbers that read like a typo. Twenty to two hundred times faster. Forty to four hundred times cheaper. Output tokens free forever. The product is Jev, from a new lab called TypeSafe AI, founded by Diogo Almeida, who helped build the methods behind ChatGPT. After two years in stealth, they released a first model that cannot write a word. It only makes decisions.

I spent yesterday reading their launch post, their homepage, and the threads around it, and doing my own homework on what checks out. This is the writeup I would hand a founder. The benchmarks need independent confirmation. The architecture bet does not need permission to be interesting.

What Jev actually is

TypeSafe calls Jev a System One Model, named for Kahneman's fast intuitive System 1 thinking and for William Stanley Jevons. The pitch is a frontier intelligence function call. Unstructured state in, typed probabilistic decisions out.

Three things are genuinely new together. A new model architecture, a parallel sampler that generates all outputs in a single query instead of one token at a time, and a training method called Reinforcement Learning for Calibrated Decisions, RLCD. Existing frontier models train with RLHF for human preference or RLVR for verifiable rewards. RLCD optimizes for calibrated decisions: answers with honest probabilities on structured tasks.

The practical shape: you send structured questions, you get typed values with confidence scores and probabilities. Possible outputs are defined in advance. The model never makes type errors. Every answer carries calibration, meaning higher confidence actually means higher accuracy, plus consistency across similar inputs. Their words for it are reliable, fast, and type-safe, more like code than like chat.

The numbers, with the caveats attached

Homepage headline: 193.6x faster, 444.6x cheaper, based on their own workflow evals for System One tasks. Their worked example: a TypeSafe call at $0.000081 completed in 0.114 seconds against an LLM call at $0.013880 completed in 8.566 seconds. Input pricing at $0.042 per million tokens, which they frame as 238x below Claude Fable 5.1, with output tokens free because they are too cheap to meter. End to end response times of 70 to 500 milliseconds against 3 to 329 seconds for frontier models on the same queries. The launch post frames the range as 20 to 200x faster and 40 to 400x cheaper.

Read their own nuance sections before quoting any of that. The evals ran from laptops on the US West Coast, where their service currently sits. Pricing sustainability is unproven by their own admission; they expect prices to fall, not rise, but cannot prove current prices are unsubsidized long term. The zero percent type error figure is structural, guaranteed by schema matching rather than measured. The workflow evals compare against the average of GPT-6 Astra and Fable 5.1 as reference answers, which biases toward those vendors and likely understates DeepSeek style models. Query authors sat on their own capabilities team. The fair summary is directionally extreme with magnitude to be confirmed, not a fabricated result but a home field one.

What is solid regardless of magnitude: parallel sampling is inherently cheaper than autoregressive token generation for decision shaped work, structured outputs remove parse and validate overhead, and calibrated confidence changes what software can do with an answer.

Why decisions beat strings inside software

This is the part that connects to my determinism work. Language models output strings. Strings can be anything: chat, code, hallucinations, refusals, or type safe values that still need parsing and validation before software trusts them. There is always residual risk the model goes off the rails, which is why production agents need human oversight.

Jev gives up strings entirely. That sacrifice buys four properties. No hallucinated tool calls buried three layers deep in a dependency chain. No parse failures at system boundaries. Parallel answers instead of sequential token streams. And confidence with every output, so code can branch on it. Their framing of the use case is AI powered workflows as smart if statements: classify, route, score, extract, or branch where handwritten rules are too brittle, with the surrounding code constraining freedom so pieces compose into reliable systems.

If you read my determinism post, this is the same war from the opposite side. There I argued for deterministic process around a stochastic model: shrink outputs to enums, enforce schema at decode time, assert on parsed fields, pin versions, budget turns. Jev moves several of those properties into the model itself. Schema matching by construction. Calibrated uncertainty by training objective. Speed that makes per decision calls affordable at 10 queries a second, roughly $7 an hour in their Doom demo, which the team itself called lower than expected.

Where it fits and where it does not

Good fit: classification, routing, scoring, extraction, verification, jailbreak detection, and judging other models' outputs. Map reduce over large data into features. Real time applications where 100 millisecond budgets rule out frontier calls. Agentic harnesses where every node currently pays parse tax and retry overhead. My deterministic versus stochastic split gets simpler when the stochastic nodes return typed confidence instead of prose.

Bad fit: anything that needs prose, explanation, or open ended reasoning. Jev cannot write, by design. Verifiable generation tasks like math proofs and kernel optimization still belong to frontier models that generate, test, and iterate. Demos that need flexibility still favor strings. Human facing chat still favors chat models. TypeSafe says as much. Their table puts chatbots, copilots, and coding agents on the LLM side and workflows, map reduce, real time, and verification on the System One side.

Open questions I would want answered before betting production on it. Cardinality caps at 255 choices, with a two stage score then choose path for high cardinality that occasionally slows down. Image inputs are not there yet; the Doom demo runs on structured state, not pixels. Reasoning enabled frontier comparisons would narrow the intelligence gap versus the non reasoning settings used in some demos. And Jev can still be wrong. Calibration means wrong answers arrive with low confidence, which is enormously useful, but the error rate itself needs third party measurement.

What I would actually do this month

Join the early access waitlist and bring one classifier. Pick the ticket router, the lead scorer, or the content moderator you already run on a frontier model with a structured output wrapper. Run both for two weeks on the same inputs. Measure agreement rate, cost per thousand decisions, p95 latency, and escalation precision: when each system says it is unsure, how often is it actually wrong.

In my experience the wrapper tax is the hidden line item. The System One LLM wrapper they used for comparison, constraining frontier models to compatible structured decisions, is itself slower and more expensive than raw generation. If Jev beats your current wrapped setup by even a tenth of the claimed margin, the monthly math moves immediately. Keep the frontier model for the prose and the reasoning. Let the decision model own the branches.

Do not rebuild around it yet. Early access plus home field evals plus unproven long term pricing equals pilot, not platform. But pilot it. The interface software can depend on is the missing piece I have been writing about all year, and this is the first serious attempt to ship it as a model rather than as harness code.

About the Author

I'm Brian Marvin, an AI-native Fractional CTO with 30 years in technical leadership. At empowered.guru, I help startups build MVPs, shape roadmaps, and make AI-powered technology decisions that scale.