TypeSafe AI's Jev: what a System One model is, what it costs, and where we're testing it

TL;DR: Jev is a model that doesn't write anything. You hand it a question with a fixed set of answers (yes/no, pick one of these, score 0 to 5) and it hands back the answer plus a confidence number, in under half a second. Other people have measured it at 18x faster and 20x cheaper than a frontier LLM for routing and classification. It can't chat, plan or write. We got early access to the TypeSafe console this week and we're running it against the decisions our own product makes every day. Our numbers aren't in yet. Everything below is what we know so far, and what we'll add once we've measured it.

Why I'm writing about a model that isn't an LLM

Most of RankNexus runs on LLMs. They write the fixes, draft the articles, score the pages. And a surprising amount of what we ask them is not writing at all. It's "is this a title problem or a description problem?", "is this page an article or a tool?", "is this draft good enough to publish?" One-word answers. We wait two, three, sometimes ten seconds for each, and we pay for every token of JSON the model wraps around its one word.

If you've built an agent or a routing layer, you've hit the same wall. You're asking a reasoning engine to sort the mail. It works. It's just slow, it's not cheap, and now and then it hands you a JSON object with a smiley face in it.

Jev is the first model I've seen that's built for the sorting, not the writing. So I signed up, and this is my notes so far.

The facts, in one table

Figure 1. The mental model: System One routes, System Two reasons.

The problem Jev is solving

Frontier models (GPT, Claude, Gemini) are built for deep reasoning, planning and prose. Kahneman would call that System Two: slow, careful, deliberate. Routing, triage and classification are System One: fast, instinctive, "obviously that one".

We've been using System Two tools for System One jobs, and it costs us in three ways:

1. You can't predict the latency. Even a one-word answer means the model reads the whole context and predicts token by token. Ask for JSON and it predicts every bracket and quote mark too.
2. You pay for scaffolding. Every output token is billed, including the {, the "category": and the }.
3. The schema breaks. JSON mode helps, but not always. So you write a retry loop, and now the slow path is twice as slow.

TypeSafe's line is that Jev is "smart if-statements". That's about right.

What Jev actually is

Figure 2. Jev (System One) against standard LLMs (System Two). Numbers from TrueFoundry and Cribl.

It samples, it doesn't generate

An LLM is a text generator. Jev is a state evaluator. You send the prompt plus the shape of the answer (a set of options, a boolean, a bounded score), and it works out the probability of every valid answer in one pass. Two options or two hundred, same pass. That's where the milliseconds come from.

It can't break your schema

Because it never writes free text, it can't hallucinate text. Ask for sales, support or spam and there is no way to get sales_inquiry back, or "Sure! The classification is sales." The retry loop and the fallback parser go in the bin.

The confidence number means something (RLCD)

This is the part I care about most. Chat models are trained with RLHF, which makes them helpful and polite and wrecks their calibration. When a chat model says "I'm 99% sure", that's a phrase, not a probability.

TypeSafe trained Jev with something they call RLCD, Reinforcement Learning for Calibrated Decisions. They say it took two years and it targets the things RLHF gets wrong: mode dropping, hallucination, unreliability. The claim is that 0.95 confidence means about 95 right answers per 100 similar inputs.

If that holds, you can write the threshold into your code. Above 0.90, auto-route. Below it, hand to a person or to a proper LLM. I'll come back to whether it holds.

The three shapes it answers in

From the console, Jev speaks in three primitives:

• Noul: a probabilistic yes/no. The demo asks "is a hotdog a sandwich?" and gets 58% true, with a calibration readout next to it.
• Choice: one option from a list, with a confidence.
• Score: a number in a range you set, 0 to 5 say, with the distribution across the levels.

If you've ever written a multiple-choice quiz, you already know how to prompt it.

Figure 3. The TypeSafe console after sign-up. Playground, API keys, usage, cookbooks. The "No usage yet" is ours, for now.

What other people measured

I haven't benchmarked it myself yet, so here's what's been published.

TrueFoundry did the latency and cost breakdown that most people quote: frontier LLMs at 3 to 329 seconds for structured classification, Jev at 70 to 500 milliseconds. On price, $0.042 per million input tokens and nothing for output, because there's no autoregressive output to meter. You pay for what you send in.

Cribl, the observability company, tested Jev on the job you'd expect them to care about: routing log lines and judging other models' outputs, at volumes where sending every line to a frontier model isn't an option. They reported 18x faster inference, 20x lower cost per prediction, and over 92% agreement with their human and LLM-judge panels.

92% agreement isn't 100%. For log routing, with a confidence score you can act on, it's plenty. For a legal decision, it isn't. Which brings us to the honest bit.

Where it stops

TypeSafe's own page lists the limits, and I'd rather quote them than soften them:

• Not good at System 2 tasks. No reasoning chains, no planning.
• Not trained on specialised domains. Your schema carries the domain knowledge; the model won't know your industry's edge cases.
• Not a generative chat model. "Jev doesn't generate text, so you can't chat with it. To ask it questions, you have to define the shape of the answer."

Figure 4. TypeSafe's own properties, limitations and benefits, signed off by the founders, Diogo, Erik and Sasha.

The founders also say, on that page, that "frontier-level intelligence for System 1 tasks" is their hardest claim to defend and nobody has a good way to prove it. I appreciate a model page that says that out loud.

Jev vs a normal LLM, side by side

When to reach for it

You don't drop your LLM. You stop making it do jobs it's bad at.

Give Jev:

• Ticket triage: which department gets this?
• Agent loop control: which tool next, and are we done yet?
• Guardrails: prompt injection, toxicity, PII, before the expensive call.
• Log and telemetry classification at volume.
• Judging: quick, cheap scoring of another model's output.

Keep the LLM for:

• Open-ended reasoning and multi-step plans.
• Emails, articles, marketing copy.
• Code, long summaries, translation.

What the code looks like

Before, with an LLM doing the routing:

1. Send the input and a few-shot prompt asking, please, for JSON only.
2. Wait about four seconds.
3. JSON.parse().
4. Catch "Here's your JSON:", strip the markdown fence, try again.
5. Route.

After, with Jev:

1. Send the input and the schema.
2. Wait about 150 ms.
3. Get back something like Choice: 2, Confidence: 0.98.
4. Route.

And because the confidence is calibrated, the tiering goes in the app layer:

// Confidence-tiered routing, conceptual
const decision = await jev.classify(ticketData, supportSchema);

if (decision.confidence >= 0.95) {
  // Sure enough to act on its own
  system.routeToDepartment(decision.category);
} else if (decision.confidence >= 0.7) {
  // Not sure: let a proper LLM think about it
  const deepAnalysis = await llm.analyze(ticketData);
  system.routeBasedOnAnalysis(deepAnalysis);
} else {
  // Really not sure: a human looks
  system.flagForHumanReview(ticketData);
}

The expensive model runs only when the cheap one says, with a number, that it's out of its depth.

Getting set up took me a few minutes. The console has a Playground, API keys and a usage page. There's an agent skill too: in Claude Code, claude plugin marketplace add typesafe-ai/skills, then claude plugin install typesafe-ai; elsewhere, npx skills add typesafe-ai/skills --skill typesafe-ai. The cookbooks are worth a look: batching a 13-question regulatory briefing into one call (they report 11.5x cheaper and 9.6x faster with identical answers), a two-stage extraction cascade, self-consistency scoring, and function calling.

Early access: what we're testing at RankNexus

We have early access to the TypeSafe console, and I've picked four places where RankNexus makes a System One decision today and pays System Two prices for it:

1. Fix classification. Before an LLM writes a fix for a crawled page, something has to decide whether the problem is the title, the description, the schema or the images. That's a Choice.
2. Opportunity typing. Article, resource or tool page. Three options, and a confidence we can threshold instead of guessing.
3. Support triage. Routing tickets in our help desk.
4. Judging drafts. Scoring an article draft against our rubric before it goes out. That's a Score.

What I'll publish, on this page, once there's enough volume: p50 and p95 latency, cost per thousand decisions, and agreement with the LLM we use today. Including the places where Jev was wrong, because a 92% model is only useful if you know which 8% it misses.

If you want that data when it lands, or you want the routing patterns we ship inside RankNexus, the waitlist is on ranknexus.ai.

A few definitions, for the record

System One model: a non-generative model that answers bounded questions (choice, yes/no, score) fast, with a calibrated confidence. Named after Kahneman's fast, instinctive mode of thinking.

RLCD (Reinforcement Learning for Calibrated Decisions): TypeSafe AI's training method. It optimises for confidence numbers that match real accuracy, instead of for text that humans prefer. Their replacement for RLHF on decision models.

Non-generative sampler: a model that evaluates a fixed input against a schema and returns a distribution in one pass, rather than generating tokens one after another.

LLM-as-a-judge: using one model to grade another model's output. Common for evals and guardrails.

Where I've landed

For two years we've hired reasoning engines to sort the post. It works, it's slow, and the bill is mostly punctuation. Jev is the first model I've used that's built for the sorting. Whether the calibration claim survives contact with our data is the thing I actually want to know, and I'll tell you here either way.

Sources

• TypeSafe AI, "Meet Jev: our first (public) System One model", typesafe.ai
• TypeSafe AI console and cookbooks, docs.typesafe.ai
• TypeSafe AI skill, github.com/typesafe-ai/skills
• TrueFoundry, "TypeSafe AI's Jev: What 'System One Models' Actually Are"
• Cribl, "What TypeSafe's Jev means for telemetry"