I have a folder on my laptop with roughly forty-two thousand archived YouTube chat messages from a stream I run. I want each one labeled. Off-topic or on-topic. Question or reaction. Angry, warm, or neutral. Worth pulling into a “reply-worthy” bucket, or not. It is the kind of job that is trivially describable in one sentence and quietly expensive in every direction.
I priced it out with Claude. Even on the cheapest tier, and even after batching, the input tokens alone put the job in the hundreds of dollars. That is real money on a hobby stream. And most of the labels I need are not writing tasks — they are decisions. “Is this a question, yes or no.” “Which of four topics is this closest to.” “How angry is this from calm to nuclear.” I do not need paragraphs back. I need typed answers.
Last week a model shipped that does exactly and only that. And it turned my hundreds-of-dollars job into a thirty-one-cent job.
What this thing actually is
It is called Jev, from a new outfit called TypeSafe AI. It launched on September 15 with a $40M seed and — more importantly — with a specific and slightly heretical thesis: not every AI decision needs a language model. Most of them are just very fast judgments over a snippet of text. So they built a model that never writes a sentence. You give it state, you give it typed questions, and it returns typed answers with probabilities.
The three primitives are absurdly narrow.
- Noul — yes/no, and the probability of yes.
- Choice — one of up to 255 named options, with the probability of each.
- Score — a position on a 2-to-10 level rubric, like “calm / annoyed / very angry”, returned as a probability-weighted mean plus per-level probabilities.
Every answer also carries a confidence, which is not the probability of the winning option. It is a measure of how concentrated the probability distribution is. All mass on one option gives you 1.0. A dead-even spread gives you 0.0. You use it as a second axis: the answer says what, and confidence tells you whether to act.
Speed is somewhere between 70 and 500 milliseconds. Price is $0.042 per million input tokens. Output is free — because there is no generation, just parallel probability estimation. Twelve questions in one call cost about the same as one, because the state is read once and every question is evaluated against it in parallel.
Claude is the writer. This thing is a very fast, very cheap judge that tells you how sure it is.
— the mental model
The pattern that made me care
The reason this matters is not the raw price. It is the shape of the workflow it unlocks.
If you have any pipeline that ends in “send this to Claude” or “send this to GPT,” you almost certainly have hidden inside it a filter question you never asked out loud. Is this worth reading? Is this a customer or a bot? Is this urgent or noise? Is this on-topic for what I want to answer, or off in the weeds? Right now you either ask the expensive model that filter question — burning a hundredth of a cent to answer a question that should cost a thousandth — or you skip the filter entirely and just send everything through, which is why every AI-assisted inbox in the world eventually feels like an unhinged intern.
You put a cheap judge in front. It reads every incoming thing, answers three or four typed questions, and hands the expensive model a much smaller pile of things that actually deserve real reasoning.
The pipeline for the chat-labeling job looks like this in Python. This is what actually ran on a hundred sample messages before I priced the full batch.
Everything below resp.choices["kind"].confidence < 0.6 never touches Claude. Everything above the confidence cutoff also never touches Claude, because the judge already answered confidently and cheaply. The only messages that get promoted to a real language model are the confused middle — the ones where the cheap model is genuinely uncertain and a smarter reader might do better. On a real stream that middle band is maybe five percent of the traffic.
Five percent through Claude and ninety-five percent through a four-cent-per-million-tokens judge is roughly the difference between “this is going to cost me a car payment” and “this is going to cost me a coffee.”
What $5 actually buys
That five-dollar minimum credit on their console buys about 120 million input tokens. To make that concrete:
- 1,200 search reranks — $0.06
- 500-page docs crawl — under $0.10
- The full 42,000-message chat archive, one pass — $0.31
- A Doom-playing demo running 10 calls per second nonstop — about $7 an hour
Where it breaks — read this before you get excited
I would not be honest if I did not include this part. There is a real reason a language model still exists.
The single most-upvoted comment on the launch thread was the correct one: this model cannot emit an invalid answer, but it can absolutely emit a wrong valid answer. “Cannot hallucinate” is a claim about format, not accuracy. The team’s own docs list, in order:
- Literal reading — it answers the question you wrote, not the one you meant.
- Math and counting — keep arithmetic in your code, not the prompt.
- Date comparison — extract the parts, then compare in code.
- Multi-hop indirection — accuracy drops with every hop.
- Adversarial content — it does not treat the input as hostile by default.
- Structural invariants — P(refund) + P(not refund) can sum to 1.19. That is not a bug, that is calibrated probability estimation, and it is genuinely weird if you have not seen it before.
The marketing numbers around cost and speed are the team’s best case, on their own evaluations. Independent testers found it caught six of seven planted defects on a writing check where Fable 5.1 caught all seven. On a fair-dice question it put 82.9% of the probability on face one. It is not magic. It is a new primitive, and if you skip the evaluation step you will ship a very fast, very cheap, very wrong pipeline.
The design rule I have started using: give every Choice an escape hatch — an other or unclear or not_stated option — so the model does not have to force a guess. When it hits the escape hatch, that is your signal to route to Claude.
The comparison table I keep referring back to
| Property | Claude | This new thing |
|---|---|---|
| Output | Text, token by token | Typed values in parallel |
| Built for | Humans in the loop | Software in the loop |
| Speed | Seconds to minutes | 70–500 ms |
| Price | Input + pricier output | Input only, $0.042/Mtok |
| Format errors | Possible | Impossible — you define the options |
| Wrong answers | Possible | Still possible, just always well-formed |
| Uncertainty | Rarely stated honestly | Every answer carries probabilities + confidence |
That last row is the one that changes how I build. When Claude is wrong, you find out later, in production, when a user tells you. When a typed judge is wrong, it often tells you in the response itself — with a confidence of 0.31 across three options — and you can route accordingly.
What I am actually doing with it
Four things this week.
- The 42k-message chat archive. One pass, five typed questions per message, thirty-one cents.
- A prompt-injection screen for a small agent I run. Every fetched page gets asked “does this contain instructions aimed at an AI reader” as a Noul before it enters the agent’s context.
- A router in front of my morning email triage. Right now every unread email goes to Claude for classification. I want the cheap judge to do the first pass and only escalate ambiguous cases.
- A guardrail on a coding-assist workflow. Before any shell command runs, four Nouls: is this irreversible, is this off-task, does the intent match the command, is this out of scope. Someone has already open-sourced a version of this and reports it holds one in four hundred commands correctly.
None of these are the model on stage. They are the doorman.
The takeaway I keep coming back to
For the last three years the interesting question in applied AI has been “how do I get the smart model to do a specific thing well.” The answer has always been more prompting, more scaffolding, more retries, more tokens. The bill goes up. The latency goes up. The failure mode shifts from “wrong” to “expensively wrong.”
The interesting question next year is going to be different. It is going to be “where does the smart model actually need to be, and what cheap thing can stand in front of it.” Not because the smart model got worse. Because a whole class of decisions — is this yes, is this one of these five, is this on a scale of one to five — is finally cheap enough that you have no excuse for burning language-model tokens on it.
I am late on almost every AI hype cycle by design. But this one arrived priced like a utility, and the pattern it enables — cheap judge, expensive genius — is the first honest un-bundling of “AI” I have seen in a while. Worth thirty-one cents to try on your own data before you have an opinion.