Jev: The Model That Doesn't Write JSON — It Returns a Type

Here's a thing we all do and never question. You want an LLM to classify a support ticket, so you ask it for JSON: {"category": "billing", "urgency": 82}. Under the hood, the model generates that answer the only way it knows how — one token at a time, character by character, {, then ", then c, a, t... — and then you parse the string it produced and hope it didn't wander off, forget a brace, or decide to explain itself in a paragraph first. We've built entire retry-and-validate frameworks around the fact that a text model asked for structure sometimes produces broken structure.

Jev looks at that whole arrangement and says: why is a classification being written out like an essay?

What Jev is

Jev is the first public model in what TypeSafe calls the "System One" class — a name lifted straight from Kahneman. System 2 is slow, deliberate reasoning; that's your frontier LLM doing chain-of-thought. System 1 is fast, intuitive, bounded judgement, and that's the gap Jev is built for: the millions of small, repeated decisions inside real software that don't need an essay, they need an answer now, in a shape your code can use directly.

The mechanism is the interesting part. Instead of generating JSON token-by-token, Jev takes your unstructured text plus a set of questions you define at call time, and returns a constrained probability distribution over the values you allowed — in a single forward pass, not an autoregressive drip. There are three question types:

• Choice — categorical (["billing", "technical", "sales"])
• Score — numeric or rubric (0–100 urgency)
• Noul — a yes/no with probabilities

The call is about as plain as it gets:

import requests

response = requests.post(
    "https://api.typesafe.ai/v1/systemone",
    headers={"Authorization": "Bearer YOUR_KEY"},
    json={
        "model": "jev-latest",
        "state": "Customer emailed twice about a failed refund...",
        "questions": {
            "category": {"type": "choice", "options": ["billing", "technical", "sales"]},
            "urgency":  {"type": "score",  "min": 0, "max": 100},
        },
    },
)

You pass program state as text; you get typed values back with calibrated probabilities. There is no JSON to parse, because there was never a JSON string — just a choice from a set you defined. A successful answer cannot contain a malformed value. TypeSafe reports this as a 0% structured-output error rate, against 0.58–45.5% for frontier LLMs on the same task. That number is the whole pitch in one line: you cannot get back something that doesn't fit your schema, because the model was never free to type outside it.

The part that will make you rethink cost

Two headline numbers, both from TypeSafe's own evaluation, so weigh them accordingly (more on that below):

• Latency: 70–500 ms, versus seconds-to-tens-of-seconds for a frontier model. It's fast enough that their demo drives a game loop ~10 times a second. They claim 40–200× faster than frontier LLMs on comparable tasks.
• Cost: roughly 1/76th of a mid-tier LLM per case. Input runs about $0.042 per million tokens; output they literally describe as "too cheap to meter" and price at free.

Their four-workflow benchmark (security response, observability, invoice processing, customer service) puts it here:

Model	Accuracy	Cost/case	Latency
Jev	67.8%	$0.0004	0.4 s
GPT-5.6 Terra	67.9%	$0.0304	10.1 s
Claude Opus 5	73.1%	$0.1761	37.8 s

So: it matches a mid-tier model's accuracy at a rounding error of the cost and latency, and it loses to a top-tier model on accuracy by a few points. That's the trade in one table — Jev is not smarter, it's cheaper and faster by two orders of magnitude at the specific job of bounded decisions.

There's one more claim worth flagging as the genuinely useful one: calibration. TypeSafe says the confidence scores actually track real accuracy, which is what makes "automate the confident cases, escalate the uncertain ones to a real LLM" a safe pattern rather than a hopeful one. A cheap classifier that knows when it doesn't know is worth far more than a cheap classifier that's always sure.

The name is the warning

Jev is named after William Stanley Jevons, and if you know one thing about Jevons it's the paradox that carries his name: make a resource dramatically cheaper to use, and total consumption goes up, not down. Cheaper coal didn't mean less coal burned — it meant coal everywhere.

Naming a "too cheap to meter" decision model after him is either very honest or very cheeky. When a per-decision LLM call costs $0.0004 and returns in 400 ms, you stop rationing it. You don't ask "is this worth a model call?" — you put a Jev call at every branch, every guardrail, every incoming event, every row of a dataset you'd never have classified before. The bill per call collapses; the number of calls explodes. I wrote a while back that price is a feature — that cheap AI changes not just your invoice but how freely you're willing to think with it. Jev is that idea taken to its logical, Jevons-shaped end.

The honest caveats

This is early-access software (launched September 15, 2026, behind a waitlist), and the numbers are the vendor's. Keep four things in mind before you build on it:

1. It cannot generate text. No summaries, no code, no explanations — only structured values. This is a decision engine, not an assistant.
2. It gives you no rationale. You get a value and a probability, not a sentence saying why. In regulated or auditable domains, "the model was 91% sure" is a harder thing to defend than a written justification.
3. The answer space must be known in advance. If you can't enumerate the choices or bound the score, Jev has nothing to do. It's useless for open-ended problems by design.
4. The benchmarks are TypeSafe's own. Run by their capabilities team, no independent reproduction yet. Treat the 40–200× and the 0% error rate as claims to verify on your workflow, not as settled fact.

And a fair skeptic's note, which Sean Goedecke made: some of the speed win is available today from ordinary LLMs with constrained decoding and clever prefilling. Jev's bet is that a purpose-built single-pass model beats bolting constraints onto a text model — plausible, but that's the thing to actually test.

Where I land

The interesting shift isn't the speed or even the price — it's the reframing. For years "structured output" meant coaxing a text model into behaving, and the entire ecosystem of JSON-mode, function-calling, and schema-validators exists to paper over the fact that the model would rather write prose. Jev throws that out and says the structure is the primitive, not a costume the text wears. Ask a bounded question, get a bounded answer, with a probability attached, in a schema that can't be violated.

Use it where that fits — routing, tagging, guardrails, scoring a mountain of records, real-time loops — and keep a frontier model on hand for the moment you need something explained. That two-tier split, fast bounded judgement in front of slow deliberate reasoning, is probably how a lot of production AI ends up looking. Jev is just the first model built to be the front half on purpose.

Tried it on your own data, or hit its limits? Tell me how it went via the links on the about page.