Jev for Dummies: 193x Faster Than an LLM and Your Output Tokens Cost Nothing

TypeSafe AI's Jev is the first frontier model that refuses to write anything. It answers typed questions instead, in 70 to 500 milliseconds, at $0.042 per million input tokens with output tokens billed at zero. That single trade, no prose for decisions, is the whole idea.

If that sounds like a small thing, count what an agent actually spends its money on. A coding agent that checks whether a shell command is safe, a triage bot that sorts a ticket, a browser agent that picks the next click: none of those steps needed a paragraph. Each one needed a pick, a score, or a yes. Frontier LLMs answer all of them by generating sentences, and you pay generation prices for every one.

What Is Jev?

Jev is a decision-only model, not a smaller chatbot. You send it a chunk of unstructured state and a set of questions with a fixed answer space, and it returns typed answers with calibrated probabilities and a confidence score for each.

TypeSafe calls the model class System One Models, borrowing Daniel Kahneman's split between fast intuitive thinking and slow deliberate reasoning, according to the launch post by founder Diogo Almeida. Jev is the first public one, shipped on September 15, 2026 and available in early access with a waitlist.

The name is the other half of the argument. Jev is short for William Stanley Jevons, the 1865 economist who noticed that making steam engines more efficient made Britain burn more coal, not less. TypeSafe's bet is that cheaper intelligence unlocks more calls, and that a model built from scratch for decisions beats one asked to pretend it is code.

Almeida's own account of where he came from is in the same post: at OpenAI he worked on the methods that made language models good at following instructions, and that research ended up behind ChatGPT.

What Is Jev Engineering?

Jev Engineering is the three-way split: an LLM writes, Jev decides, code acts. The term is three weeks younger than the model, and it did not come from TypeSafe.

Three X guides published on September 18 and 19 named it independently and then converged on the same rules, traced by the community directory Made with Jev, which is independent of TypeSafe. The guide that started it passed 340,000 views in a day; the version that landed on the front of this story arrived the next morning. All three use the same worked example: an agent that researches three tools and drafts a briefing.

The sorting rule is the useful part, because it is checkable in seconds:

• Creates text: an LLM does it. Draft the briefing, summarise the paper, fill the form field.
• Picks, scores, or answers yes or no: Jev does it. Which worker acts next, how relevant is this source, is this command safe.
• Follows an exact rule: code does it. Stop after ten actions, never publish without approval.

Once decisions are their own layer, you can benchmark them, batch them and price them separately from the generation you cannot avoid.

What Do the Three Question Types Actually Do?

Three primitives cover almost every fork in an agent: Choice, Score, and Noul. All three arrive in one request and come back in one response, and the quickstart docs show the exact shapes.

• Choice picks one option from a list you supply, each with a description, and returns the pick plus a probability for every option. The ceiling is 255 options; above that Jev scores candidates independently first and then makes an explicit choice, which is where the slower tail comes from.
• Score places the state on a scale you define in words, and returns a number. Ask how frustrated a customer reads on a calm-to-angry scale and the docs' example returns 1.035 with a confidence of 0.842.
• Noul answers a yes-or-no as a probability between 0 and 1. A Noul near 0.5 means the model does not know, which is the answer an automation needs most and an LLM is worst at giving.

The Word "Noul" is Jev's own; the other two are named the way you would name them.

What Does Jev Cost, and How Fast Is It?

TypeSafe's headline numbers are 193.6x faster and 444.6x cheaper, and the company publishes the arithmetic behind them.

• Input tokens run $0.042 per million, which is $42 per billion.
• Output tokens are free. TypeSafe's own gloss is that they are too cheap to meter.
• End-to-end response time is 70ms to 500ms, against a published 3 to 329 seconds for frontier LLMs on the benchmark the launch post cites. TypeSafe frames the comparison as 40x to 200x faster for decision-shaped queries.

The caveats are on the same page, which is what makes the numbers worth quoting. TypeSafe states plainly that the published evals were run from laptops on the West Coast, that it cannot prove its pricing is not subsidised, and that output tokens being free is a pricing decision the long term has to justify. It also notes that speed and cost are the easy claims to verify, while the bolder ones are not.

Outside measurements are thin so far. One third-party agent integration, pi-jev-auto-mode, reports judged calls landing between 193 and 642 milliseconds across eleven ordinary shell commands, and treats the semantic layer as worth roughly half a second per judged call.

Where Does Jev Not Belong?

Keep Jev out of writing, arithmetic, and anything irreversible. It cannot generate a string, cannot look anything up, and cannot return a value outside the schema you defined, so every task that needs any of those belongs to an LLM or to ordinary code.

The failure mode to design against is not a wrong answer. It is a confident one. TypeSafe's pitch is that a calibrated confidence lets your code decide when to act alone and when to ask a human, which means every workflow needs a threshold, and the threshold is yours to set. Send everything to Jev and you will automate the decisions you should have kept.

The directory's own tally is worth hearing as a creator: of 186 builds listed, 42 are agents and browsers and 20 sort queues into buckets. The popular uses are routing and scoring, not editing. Scoring footage against a brief, catching slop, or deciding which generation to keep are the same shape of question as sorting tickets, and they are the ones Jev is built for.

How Do You Start With Jev Today?

Three routes, and the fastest needs no code at all. Jev's own docs lay them out, and the Playground is first.

• Playground. Log in, paste text as the state, add a Noul question such as "Does this message express urgency?", then mix all three question types in one call.
• API. POST https://api.typesafe.ai/v1/systemone with Authorization: Bearer <API_KEY>, model: jev-latest, and a questions object. Keys come from the dashboard at console.typesafe.ai.
• Python SDK or agent skill. pip install typesafe-sdk needs Python 3.10 or newer and reads TYPESAFE_API_KEY from the environment. Coding agents can install TypeSafe's own skill with npx skills add typesafe-ai/skills --skill typesafe-ai.

Start with one repeated decision, measure the loop rather than the individual call, and only then replace the next LLM call in the chain.

Early access is the honest answer to availability: TypeSafe says it is opening access and working through the waitlist as fast as it can, so a key today may take a queue to arrive.