The model that will take 70% of the decisions away from ordinary LLMs. What is Jev?

$42 per billion input tokens. Not per million, per billion. A million costs a little over four cents, and at that price the habit of rationing model calls stops making sense. What the harness around those calls costs is a separate bill, and we counted it when we compared Claude Code, Codex and pi on money.

That is exactly what the name plays on. Jev is short for Jevons: the Jevons paradox says that making a resource cheaper does not reduce its consumption, it raises it. When a decision costs hundredths of a cent, people stop saving them up and start asking the model in places where they used to write a regex and hope.

The model that refused to talk

For several years the industry walked in one direction. RLHF taught models to please people, and we see the result daily: instruction following is superb, reliability is not. The model is confidently wrong, drops parts of the answer space, and needs a human next to it.

TypeSafe walked the other way. Their algorithm is RLCD, reinforcement learning for calibrated decisions, and what it optimises is not human approval but the honesty of a probability. The company was founded by Diogo Almeida, a former OpenAI researcher and a co-author on RLHF and InstructGPT, meaning the person who built the thing he is now pushing away from.

The trade is blunt: Jev writes no text. None. Not a line, not a list, not a short summary. In exchange it answers in tens of milliseconds and cannot invent a value that is absent from your schema, because it only picks from what you listed.

The three questions it understands

The whole interface is state plus a dictionary of questions. There are exactly three kinds. Choice picks one option from those listed, up to 255 of them. Score rates content against described levels. Noul returns the probability that a statement holds.

What matters is not the primitives but that every question in a request is evaluated in parallel against one state. The authors publish a measurement: thirteen questions about the GDPR article, sent as one call instead of thirteen, come out 12.2x cheaper and 10.0x faster, with the same answers.

The first objection here is obvious: how is this different from the structured output any modern LLM can do. Two differences, both load-bearing. A normal model still produces its answer token by token, and the schema only validates what came out, whereas Jev samples every option at once and a type error is excluded by construction. And the answer arrives with calibrated confidence, a number you can hang a threshold on. Hence the working pattern from the docs: above the threshold your code acts by itself, below it the case goes to a human, and both paths are written in advance rather than guessed from the tone of a reply.

curl -X POST https://api.typesafe.ai/v1/systemone \
  -H 'Authorization: Bearer $TYPESAFE_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{ "state": "...the incoming message...",
        "model": "jev-latest",
        "questions": { "is_urgent": { "type": "noul",
          "instructions": "The message conveys urgency" } } }'
# python: pip install typesafe-sdk   (0.7.0, 18 September)
# js:     npm i @typesafe-ai/sdk     (0.6.0, 15 September)

Where it sits inside an agent

Not instead of the LLM, but between it and your code. Every point where an agent picks a worker, scores a source or decides whether to call a human is a question with a finite set of answers, and paying for that with text generation is no longer required. How to split your own loop into generation and decisions, where those points hide and what to put on the confidence threshold is worked through step by step in our guide to agents on Claude Code and Jev.

The ecosystem caught up within a day. Vercel added the model to AI Gateway on 16 September as typesafe-ai/jev, calling it through experimental_evaluate in the AI SDK, and two days later reported it as the fastest-adopted launch in the gateway's history: roughly 13 percent of paid teams within the first 24 hours. LangChain shipped a TypeSafeClassifier. Claude Code has an official plugin, installed with claude plugin marketplace add typesafe-ai/skills. If you have not sorted out how a skill differs from a plugin and when you want your own, we have a separate guide on skills.

Where it breaks

This is the best part of the documentation and the part no thread mentions. TypeSafe keeps a page on the jagged edges of jev-1.13, last reviewed on 17 September, and it lists nine acknowledged failure modes.

The model reads literally and answers the question you wrote, not the one you meant. It is not a calculator: it does not tally a list, it recognises the shape of an answer, and the error grows with the list. It reads dates as text, so comparing them is out; extract the parts and assemble them in code. Accuracy drops when the state is padded with material the question does not need, which is the same discipline we teach on the Claude Code memory course: put what the job needs in the window, not everything you have. And structural invariants do not hold: in the authors' own example, a question and its negation asked as two Nouls return 0.72 and 0.47, summing to 1.19.

One more thing worth naming. English is the primary training language; everything else is supported but weaker. For Russian or Hebrew content that means measuring on your own material instead of importing someone else's confidence thresholds.

What we checked ourselves

We intended to run the model by hand, the way we do with every tool. It did not happen: access runs through a waitlist, and the button on the home page says exactly that. So every number here comes from the source, which beats repeating someone else's.

The detour showed why the source is worth the trip. We went to Forbes for the figures first; it returned 403 to a plain request, and its headline says "100x". TypeSafe's own front page says something else: 193.6x on speed and 444.6x on cost. The retelling did not survive the comparison.

One more observation from npm and PyPI: the clients have drifted apart. The Python package typesafe-sdk reached 0.7.0 on 18 September, while the JavaScript package @typesafe-ai/sdk sits at 0.6.0 from the 15th. The project is a week old and that is fine, but if you are building on JS, check feature parity before you commit.

About the number in the headline: those 70 percent are our estimate of the share of calls that really come down to a choice, a score or a yes-or-no, not a measurement and not a TypeSafe figure. Treat it as a bet we are willing to defend.

Our opinion, and you are free to disagree: there is exactly one place for Jev right now, and it is narrow. It is the fork with a finite set of answers that you currently pay for with text generation: picking a worker, filtering sources, gating an irreversible action. Do not move counting, dates or whole-document reading there, that list is literally the jaggedness page. And if your content is Russian or Hebrew, a measurement on your own sample belongs between "interesting" and "we are shipping it": confidence thresholds borrowed from someone's English example will not transfer. What that measurement looks like for a site's pages is in our breakdown of auditing pages for AI answers, and the whole road from a one-off check to a process runs through the SEO automation course.