Jev by TypeSafe AI: Typed LLM Decisions Instead of Text

Language models have been superhuman at chat for years, so where’s all the automation? TypeSafe AI asks exactly that in its Jev launch post, and I think they’ve got a point. Code wants true or false, one of five categories, a number between 0 and 1. An LLM hands you a paragraph. So you write a fragile parser, then a retry loop for the day it wraps the JSON in markdown, then you sit there for ten seconds while it thinks out loud.

Psychologists split thinking into System 2, the slow deliberate kind (chess, essays), and System 1, the instant kind (“is this email spam?”). LLMs are System 2 machines even when the job is System 1. Routing support tickets with one is like hiring a novelist to stamp envelopes. It works. It’s slow, it’s pricey, and every so often you get a short story back.

TypeSafe’s answer is what it calls a System One model, and Jev is the first.

Think of Jev as a frontier-intelligence function call: unstructured state in, typed probabilistic decisions out.

What Jev actually is

You give it some state (text, a JSON object or an array) and a set of typed questions, each with its own instructions. It gives you typed answers with probabilities. Three question types:

booleanYes or no, as a probability from 0 to 1. “Is the customer asking for a refund?” gives 0.98.

choicePick one from a set you define, with a probability for each. “Route this ticket” gives billing: 0.97, shipping: 0.02, technical: 0.01.

scoreRate something on a scale you describe, like poor / fair / good / excellent. You get a score such as 2.97 plus the probability of each rung.

A full call through the Vercel AI SDK:

import { experimental_decide as decide } from 'ai';

const result = await decide({
  model: 'typesafe-ai/jev',
  state: 'I cannot log in, and I also want a refund for last month.',
  questions: {
    authIssue:   { type: 'boolean', instructions: 'Is there a login problem?' },
    wantsRefund: { type: 'boolean', instructions: 'Is a refund requested?' },
    urgency:     { type: 'score', instructions: 'How urgent is this?',
                   criteria: ['low', 'medium', 'high'] },
  },
});

result.answers.wantsRefund.probability; // 0.97

No begging for JSON, no repair step. It literally can’t give you a malformed answer.

Try it: the triage desk

Pick a ticket and see what a System One model returns.

The numbers here are illustrative, hand-written to show the shape of the response. They are not live Jev calls.

Why it’s fast and cheap

An LLM writes one token at a time, and each one has to wait for every token before it, so the longer the answer, the longer you sit there. Jev doesn’t. It’s trained with Reinforcement Learning for Calibrated Decisions (RLCD) and answers every question in parallel in a single pass. Nothing to stream.

Try it: the token race

Same task, two ways. Press run and watch which one finishes.

LLM (sequential)

Jev (parallel)

Left is an LLM generating a verbose answer token by token. Right is Jev filling its whole answer at once. Illustrative animation, not to scale.

TypeSafe reports 70 to 500 ms end to end, which it puts at 40× to 200× faster than frontier LLMs on similar tasks. On price, Jev charges $0.042 per million input tokens and nothing for output, and output is where a chatty LLM racks up most of its bill. Extra questions are nearly free, since they all run against the same state. One cookbook example asked 13 questions in one call and came out 12.2× cheaper and 10× faster than asking them one at a time.

Is it any good, though?

TypeSafe’s benchmark uses the biggest models’ predictions as the reference answers. The result:

Model	Accuracy	Cost / case	Latency
Jev	67.8%	~$0.0004	~0.4 s
GPT-5.6 Terra	67.9%	$0.03 to $0.18 (range across the comparison set)	10 to 38 s
Opus 5	73.1%	same range	same range
GPT-5.6 Sol	74.1%	same range	same range

The source gives one cost and latency range for the LLM group, not per-model figures. All numbers are TypeSafe’s own, unaudited by third parties.

So Jev roughly ties one big model and trails the best by about six points, at 75× to 450× less per case. Make that decision a million times a day and it’s an easy trade. Once, with real stakes? Maybe not.

Calibrated confidence is the real trick

An LLM will tell you it’s 95% sure about almost anything. Jev is trained so that higher confidence actually means higher accuracy, and that changes how you build:

const { probability } = answers.isSafe;

if (probability > 0.95)      runIt();
else if (probability > 0.60) askHuman();
else                         reject();

Jev takes the sure cases and flags the rest. Vercel’s AI Gateway can even re-run a request on a bigger model when Jev’s confidence lands in the murky middle. Cheap by default, expensive only when it matters.

Where it shines

Routing and triageTickets, forms, emails, leads. Ask ten questions (topic, urgency, sentiment) in one call.

Guardrails for other AIAsk “is this shell command destructive?” before every agent tool call. It’s cheap enough to check every action.

LLM-as-judge, minus the billScore outputs against a rubric in evals or CI.

Search and re-rankingScore candidates against a query with no embeddings or vector database, like the project below.

Case study: a search engine made of one function call

I built PageLens, a Chrome extension that highlights the bits of a page that answer your question, by meaning rather than keyword. No embeddings, no vector store. The page gets split into chunks, and each chunk becomes one score question in a single Jev call.

questions[chunkId] = {
  type: 'score',
  instructions: `How relevant is passage ${chunkId} to the query?`,
  criteria: ['not relevant', 'somewhat relevant', 'relevant', 'highly relevant'],
};

Scoring 80+ passages takes about as long as scoring one.

Try it: PageLens, miniature

Drag the threshold to decide which passages count as matches.

Query: "why did the deploy fail?". Each passage below got its own score question.

Minimum score: 1.50 / 3

Scores are sample values in the style of real PageLens output.

What I learned the hard way:

Documented limits aren’t usable limits. The docs say tens of thousands of tokens. In my testing 89 questions (~15k tokens) worked every time, while ~118 (~20k tokens) hit 503s that wouldn’t go away. PageLens now caps batches at 12k tokens / 80 questions.
Each question has to know who it is. With identical instructions, Jev gave nearly the same answer every time: 2.95, 2.95, 2.96, 2.96 on passages that should have spanned 0 to 3. Putting the chunk id in each question fixed it: 0, 3, 0, 1.19.
Don’t spend Jev where a regex will do. Checking for an exact phrase is string work. Save the model for meaning.

What Jev is not

It can’t write. No summaries, no explanations. It’s bad at counting, arithmetic and comparing dates, contradictory criteria confuse it, and for now it only takes text. And every number above is TypeSafe’s own, with demos that run in simulators, so test it on your data before you believe any of it.

The takeaway

Jev’s bet is that most of what software needs from AI isn’t conversation. It’s a fast, cheap, calibrated judgement inside an if statement. Ask everything in one call, combine the probabilities in code where you can test them, and only escalate the cases it isn’t sure about. If that bet’s right, the next wave of AI features won’t look like chat boxes at all.

Try it on one boring classification job you’re currently paying a big model for, and compare the bills.

Jev: the AI that doesn't talk (and why that's the point)