Jev by TypeSafe AI: 193× in the Retweets, 5× in the Measurements

Collected 15–17 September 2026, the first three days after launch. Every vendor figure below was re-read from TypeSafe’s own site and docs on 17 September; every practitioner number comes from a tweet quoted in place. This category moves weekly.

Your agent needs to decide which model handles the next step. So it calls a frontier model, which thinks for four seconds, writes two paragraphs explaining its reasoning, and ends with the word codex. You pay for the paragraphs, wait for the paragraphs, then throw them away and keep one token.

That call is the thing TypeSafe AI built a model for. Jev launched on 15 September with “20–200× faster, 40–400× cheaper, output tokens free.” The announcement thread has 29.8 million views.

We collected everything written about Jev on X in its first three days — 21,451 tweets, of which 8,840 are about Jev and carry usable content — and pulled out every number anyone stated, tagged with whether that author measured it themselves or was repeating the vendor.

The price is a published rate rather than a claim. The multipliers do not survive contact with other people’s benchmarks, and the latency lands inside the band TypeSafe states — closer to its ceiling than its floor.

Two details about those headline numbers are worth having up front. First, the median of the figures being repeated across the corpus is 193× — the homepage number, rounded. People are not estimating, they are quoting. Second, the homepage puts a worked example directly beneath its own headline: TypeSafe at $0.000081 and 0.114 s against LLMs at $0.013880 and 8.566 s. That example is 75× faster and 171× cheaper, not 193.6× and 444.6×. The headline carries a footnote — “Based On Workflows For System One Tasks” — so the two need not match, but the gap between a vendor’s banner and the vendor’s own illustration is a useful preview of the gap between the banner and everyone else’s runs.

This is not an independent benchmark. It is a survey of what practitioners said in public in the three days after launch, with the method and its limits at the end.

What it actually is

Jev does not generate text. You pass it unstructured state plus a set of typed questions, and it returns a probability for each option in one parallel pass instead of token by token.

The line the corpus repeated verbatim, dozens of times:

LLMs generate answers. Jev makes decisions.

In practice: instead of asking “is this user risky?” and parsing whatever comes back, you declare risk: low | medium | high and manual_review: yes | no, and receive risk = high (96%), manual_review = yes (91%). No prompt begging the model to answer with one word, no JSON repair, no retry because a comma moved.

Pricing is $0.042 per million input tokens, and output tokens are free — there is no output to bill. The company raised a $40M seed led by DCVC. The founder, Diogo Almeida, co-authored RLHF and InstructGPT. The training method is new and called RLCD, reinforcement learning for calibrated decisions.

TypeSafe calls the category System One models. Every piece of company material repeats the same positioning: not a replacement for a chat model, a cheap decision layer in front of one.

Why 193× becomes 5×

The gap is not dishonesty. It is that everyone compares against something different, and the headline picks the most flattering pairing available.

Each extracted number in our data carries its baseline, and the baselines are all over the place: Opus 5, Gemini, gpt-5.6-luna, “deepseek alone”, Astra, gpt-5.4-nano, Claude, Sonnet, “our previous setup”. A headline multiplier comes from the most favourable pairing — a heavy reasoning model on a task that needs one bit back. A practitioner measures against whatever is already in their pipeline, and that is usually something small and cheap already.

Hence the spread in self-measured numbers: 25th percentile 1.9×, 75th percentile 10×. What you gain depends entirely on what you are replacing.

There is also a methodology complaint, made by @nurbolatsn: the viral side-by-sides show an LLM writing a paragraph that then has to be parsed. But you can just instruct the LLM to answer y or n. Part of the advertised win is an artifact of not constraining the opponent.

Latency is the one number where the vendor’s band and other people’s runs agree — and the agreement cuts both ways. Self-measured per-call latency has a median of 270 ms (n=108, quartiles 178–400 ms): inside the 70–500 ms band TypeSafe states, but closer to its ceiling than its floor. Sub-second decisions are real, sub-100 ms ones are the exception. That still changes which designs are possible — a decision per block, per DOM element — but a decision per frame is not among them.

What people built in the first three days

Of 8,840 relevant tweets, 2,024 come from authors who ran it themselves — 1,412 unique accounts, 23% of the corpus, in three days when access was gated by a waitlist.

The cases where authors published their own measurements:

Two of those report higher accuracy alongside lower cost. That is not a paradox: they are comparing against the small cheap models they were already using out of economy, not against a frontier model.

For anyone running agent sessions, the relevant cluster is narrower than the demo reel suggests. Routing appears in 604 tweets, classification in 565, ranking and scoring in 263, tool selection in 108. Several people describe the same pattern: put the decision model in front of the expensive one, let it pick the target or filter the candidates, and send only what survives to the model that writes code.

The concrete versions of that pattern in the corpus: routing between Claude Code, Codex and OpenCode from a local harness; filtering candidate files before they reach Claude; replacing the reasoning step of tool-calling while keeping Fable, Astra and Opus for the work itself; a second verifier that checks an agent’s pull request description against the actual diff before merge; a GitHub app that catches agents passing CI by weakening the test; PII redaction on support messages inside Postgres; and a rule engine where you write the condition in plain English once and the agent stops interrupting you — 0.7 s per check, $0.0001.

The games — Doom, Mario, Tetris, Minecraft, chess against frontier models — have the highest share of authors who ran them personally (43%). They are the cheapest thing to point a decision model at. Nothing in the corpus suggests they go further than a weekend.

The unusual ones

A launch is also when people find out what a primitive can be bent into. These are all first-hand builds from the corpus, and several of them map the shape of the thing better than the benchmarks do.

A text generator built out of a model that cannot generate text. @ryanvogel asks Jev 29 yes/no questions per character — should the next key be a–z, space, comma or period — appends the highest-probability answer, feeds the string back, repeats. An LLM reconstructed from pure classification, one character at a time. Useless as a product, unusually clarifying as a demonstration.

Othello against a real solver. A Japanese developer gave Jev the board state and had it pick the highest-probability square, then rendered its predictions as a red heat map next to a blue one from negamax search with alpha-beta pruning. Not a video of a model playing a game — a side-by-side against the classical algorithm for the same job.

150 synthetic customers, ¥1.8. @ytiskw built a purchase-intent survey: 150 fictional personas, 12 questions each via API. Total cost 1.8 yen, total time about 5 seconds, and that included a Japan-to-US round trip on every call.

The X algorithm, rebuilt. @leojrr reimplemented feed ranking with real weights and a global timeline, using Jev to simulate how viral a post would go.

A live BS meter on a presidential debate. @chetaslua ran every sentence from both candidates through five yes/no questions: 1,191 calls, 1.18M tokens, 415 ms median, $0.0497 for the whole debate.

An ad blocker that reads the page instead of matching URLs. @iam_zachi classifies every DOM element as ad or not-ad and removes the ones that are — no filter list to detect, nothing to keep updated.

Reverse-engineering the architecture from its type signature. @vinnylarouge published a repo for training your own “jevlikes” after working backwards from what the API returns.

And the one that says the most about where this goes. @steveruizok got early access and asked it to rate their Hinge profile. When judgement costs a hundredth of a cent and comes back before you have finished reading the question, it stops being something you budget for and starts being something you point at whatever is in front of you.

How this differs from what you already have

For anyone who has shipped a classifier, the obvious question is what Jev does that a fine-tuned encoder does not. Forty-five tweets name encoders, BERT or DeBERTa, or fine-tuning directly, and the argument is worth reproducing because it is the decision most readers actually face.

The case that nothing is new: @alexisgallagher notes that fast, cheap, zero-shot classifiers have existed for years, and that people who need fast, cheap and good usually train their own. His own conclusion is measured — “if Jev is good, that’s a step forward. And if it’s also even stronger than trained classifiers, even better.”

The case that the comparison misses the point comes from what the alternative costs in time. A Japanese developer put it plainly: what Jev does in milliseconds is what used to take one to two months of collecting data and fine-tuning a classifier per task. A zero-shot decision model does not beat a trained classifier on the task the classifier was trained for — it removes the project that produces the classifier. For a workflow with forty different decisions in it, that is forty projects you do not start.

Against structured outputs and JSON mode, the difference is narrower and mostly economic. @AlecTPhD: until now the only cost-effective way to get “fuzzy schema population” was Haiku, with the intelligence that implies. You could always constrain an LLM’s output — with logit_bias, with grammars, with a JSON schema — but you still paid for a forward pass built for generating prose.

Whether that difference is architectural or just packaging is genuinely contested. Several people shipped 1B fine-tunes with constrained decoding and called them equivalent, which @4rcherhume dismissed sharply: “the grifters are dropping 1b fine tunes with constrained decoding and saying it’s the same as Jev. Way to out yourself.” @austinvhuang, who trained his own small version, lands on the other side of the same question: “It’s not ‘just a classifier’ nor ‘parallel sampling from a prefix’.” Nobody outside the company can settle it, because the weights are closed and the vendor’s own eval runs on the vendor’s own harness.

Two practical notes from people already working around it. You cannot fine-tune Jev on your own data — @rileybrown asked outright (“i want to fine tune my own jev based on my own data. Is this possible?”) and nothing in the corpus or the API answers yes. And at least one developer inverted the relationship: use Jev to label a dataset cheaply, then fine-tune a small model on that labelling and serve it yourself.

What you can run today

The waitlist gates the model, not the pattern. Within three days the repositories below appeared, and the ones relevant to agent stacks are runnable without access to Jev itself:

The two open reimplementations are the most useful thing here for anyone who wants to test the shape of the idea against their own workload before joining a queue. Neither claims parity with the closed model.

Where it breaks

All of the following is concrete — a limit someone hit in their own build, or found by reading what a demo actually feeds the model.

No image input. The docs are explicit — “Jev currently accepts text input only. Images, audio, and video are not supported (yet)” — so every viral “Jev plays Doom” and “Jev drives a car” demo runs on pre-parsed text state. @FakePsyho laid it out: the input is a dump of monster and item positions, heavily preprocessed to simplify the decision. The same point was made independently about the self-driving demo — empty environment, state handed over ready-made, while perception is half the problem.

A Jev-only loop has no recovery in it. @mdlahfir drew the line precisely: “Jev is not an agentic loop; it’s a decision point” — it answers which element to click, not “a click resulted in this, let’s try this.” A Jev-only loop is possible, but “retry/fault revocation/resolution is not.” Recovering from failures, re-asking and escalating stay with the code around it.

Some decisions still go up. Both people who put Jev on code review built the same escape hatch: @hetsaraiya runs it as a first-pass merge gate where “High uncertainty → escalate to the full reviewer,” and @daniel_priscu has it grade findings so that “low confidence escalates to a bigger model.” The cheap layer removes volume, not the expensive layer.

The bottleneck may not be the model. “OCR is the bottleneck,” from a computer-use build: Jev answers in 90 ms and screen recognition eats the rest.

Answers are not optimal ones. The same PR-review author pointed it at a Rubik’s cube: 94 moves against an optimal 22. For anything where optimality is the point, that matters.

The confidence number deserves its own paragraph

Jev returns a probability with every decision, and that probability is the feature people reach for when they automate something consequential. Two of the corpus’s use-case clusters are decisions about people: safety and moderation (238 tweets, 89 of them from authors who ran it) and support and triage (140 tweets, 48 first-hand). Fraud checks, candidate filtering and document triage into discard/rework recur across both.

@AgomaMitchell flagged the thing worth pinning up next to that: a 0.95 confidence is not a 95% chance of being right. The field describes how concentrated the model’s probability mass is, not calibrated accuracy on your data. Those two agree only if you measure them into agreement.

This is where the vendor’s own evidence stops being able to help you. The founder has stated plainly that public evals “are not a good sign” of intelligence because “they reward bad actors,” and has “precommitted to de-emphasizing public evals (even if we look good).” The company publishes one regardless, at evals.typesafe.ai: four workflows — security incidents, agent-trace review, invoice processing, customer service — with Jev plotted on accuracy against cost and time next to Opus 5, Sonnet 5, Haiku 4.5, Luna, Sol, Terra and DeepSeek V4. Read the method, though, and the ceiling is visible from the page itself. There is no ground truth: the reference labels are “an average of the responses of GPT-6 Astra and Claude Fable 5.1, both at high thinking,” so the eval measures agreement with two frontier models rather than correctness. And the harness is not up for debate — “instead of debating the correctness of the harness and labels, we assume that the code is correct.” It is a real, legible, self-graded comparison. Whatever calibration curve your own use case needs, you are still plotting it yourself.

“Hallucination-free” is true in a narrow sense: with no text, nothing can be fabricated. The model can still pick the wrong option inside a schema you defined.

The criticism worth reading

Explicitly negative tweets are 3.9% of the corpus — 348 of 8,840 — but 949 carry a concrete objection.

“It’s a really smart switch statement.” The most-viewed critical piece in the corpus, at 590k views, from @NathanFlurry: “jev does not replace gpt / claude, jev is just a really smart switch statement — like if 2016 ml classifiers got 2026 levels of intelligence. it’s a new* type of tool… * = and by new, i mean rebranded.” @alexisgallagher added the sharper version: the most interesting thing about the reaction is that it revealed how many people did not know encoder-only classifiers exist, and have been useful for years.

The counter, from someone who did the work. @austinvhuang trained his own small version and reported: “It’s not ‘just a classifier’ nor ‘parallel sampling from a prefix’.” The simpler counter is economic — if your agent only needed a classifier, count the reasoning tokens you currently spend choosing a tool.

The launch was engineered, and someone said so. @MatijaSosic, whose 45-second explainer passed 900k views: the team understood they were at risk of being labelled “just a classifier,” so they deliberately used big words — AGI, 200×, ChatGPT creator. The explaining was then done for free by everyone else.

Closed weights. Two independent open reimplementations on Qwen appeared within days, plus promises of open weights. In the blockers people name themselves, access dominates: 507 mentions of the waitlist and 363 of “no access,” against 112 for trust and 24 for price. The constraint right now is supply.

Where it fits in an agent stack

It fits where your pipeline already makes small closed-question calls: which model takes this task, is this file worth sending to the expensive model, does this tool call need a human, is this output good enough to merge. The telling sign is that you already swapped in a small cheap model there and accepted its accuracy. That is the comparison where the corpus contains measurements showing both lower cost and better accuracy.

It fits where a decision has a hard time budget. 270 ms against seconds changes what you can put inside a loop.

It does not fit where the output is text, where the task is planning, or where the input is an image. The first is by construction, the second sits badly on a format of pre-declared questions, the third is unsupported.

It does not fit if you are not going to measure. The vendor’s benchmark is graded against its own harness and frontier-model consensus rather than ground truth, and every multiplier in circulation was obtained against somebody else’s baseline.

Method and limits

Search API over X, 3,841 requests, 15–17 September 2026: 21,451 unique tweets, 10,596 matching a Jev/TypeSafe filter, 8,840 judged relevant — the base for every share above. Raw responses were stored verbatim and filtered afterwards. Each tweet was labelled across 18 fields, every judgement quoting a span that is checked automatically against the text, at 98% agreement with 50 hand-labelled tweets; claimed versus measured comes from a per-number source field. Medians are computed within a single unit, because one metric arrives carrying multipliers, percentages, durations and item counts at once: multiplier medians use only ×-factors, the latency median only milliseconds — figures given in seconds prove to be whole-batch times or the baseline model’s latency rather than one Jev call.

Limits. Self-reports are not a benchmark: tasks and baselines differ, and wins get published more readily than disappointments. The sample skews to its last day — 286 relevant tweets dated 15 September, 2,731 the 16th, 5,823 the 17th — so it is a slice of the wave, not a census. “Ran it once” versus “runs it in production” scored 64% against hand-labelling and was dropped: every usage figure answers who ran it, not who shipped it, and where a row mentions production that is the author’s own wording.