Jev decision model sparks evaluations, UX use cases, and a rapid clone race

Jev is a brilliant decision model. Gemini Flash-Lite is the model nobody talks about, and it’s fast, accurate, and nearly free. Here's what we measured picking between them, and why the pair is the cheapest setup of all. Jev is the most hyped model right now. TypeSafe's decision model doesn't chat and doesn't write. It reads some text and a list of options and returns calibrated probabilities over those options. A few hundred milliseconds, for almost nothing. Every feed I read has a post about it. We had a real job for exactly that kind of model, already running in production on something much less fashionable. So instead of reading about Jev, we put it on our own data, ran both models a few thousand times, and kept score. I love Jev. I'm still using Gemini Flash-Lite. Here's why. This is the long version of a lightning talk I gave at AI Tinkerers NYC on October 7, 2026. The slides are on Speaker Deck. The setup A test that passes when the code is broken is worse than no test. With no test, you know you don't know. With a false green, you ship. At Major League Hacking (MLH), we grade AI coding agents with benchspec, an open-source eval runner we built for the job. You write what an agent should have done as plain-English checks in a markdown file. benchspec runs the agent in a sandbox and grades every check, with and without the skill under test, so the difference is what the skill actually teaches. After a run, the checks look like this: - ./.meta/index.md exists - Exactly six files match ./.meta/templates/*.md - The summary faithfully reflects the three key facts from the source Each check gets verified one of two ways. Cheap code: does this path exist, how many files match this glob, does this file have a line matching a pattern. Free, instant, exact. Or an LLM judge reads the content for meaning. That costs money every run. A classifier, the router, reads each check and picks a checker (file_exists, glob_count, regex, a few more) or defers to the judge. The router's job: one check in, one checker out, or a deferral. The router's two mistakes aren't equal: Send something to the judge that code could have handled: you lose a few cents. Send something to code that code can't actually verify: a broken result reports green and nobody finds out. The person who trusted that green ships on it. We lose a user's trust. Cents come back. Trust doesn't. So: when in doubt, defer. The secret The router I actually run is Gemini Flash-Lite, the smallest of Google's three Gemini tiers. Pro is the frontier model. Flash is the everyday one. Flash-Lite is the one Google itself describes as built for "high-volume, latency-sensitive tasks like translation and classification". Flash-Lite has the same million-token context window as its bigger siblings, an answer in well under a second, and $0.30 per million input tokens. The current version, 3.5, shipped in July. It got a line in the release notes and no keynote. Nobody hypes it, but they should be. 99% of my monthly LLM calls go to Flash-Lite. That number comes from my own AI Studio usage page, across every project I have. Pro got nothing. Flash, almost nothing. And the calls are long in, short out: the shape of classification work. Then Jev showed up. Text in, probabilities over a fixed set of options out, nothing written, by design. $0.042 per million input tokens, output free, a few hundred milliseconds. For a router, that's a perfect pitch. Round 1: the mistake you can't afford The experiment is simple. Our router is a single call with one job: read a check, pick a checker or defer. We swapped Flash-Lite out of that slot, put Jev in, and ran the same checks through both. Each model got its own prompt and nothing else changed. Here are eight real ones. ✓ is safe, ~ is over-cautious (deferred when code could have done it), ✗ is dangerous: Jev made three dangerous (false positive) calls. Two checks need the content read for meaning, and Jev sent them to regex. A regex can find a source: line. It can't tell you whether that line names the right move. The third: "no .DS_Store anywhere" is about the whole tree, and Jev picked a checker that looks at one path. It passes on a repo full of .DS_Store files. Flash-Lite: zero false positives. Over-cautious twice, which costs cents (not trust!). Make No Mistakes Jev reads literally. TypeSafe's own docs say it answers the question you wrote, not the one you meant. So I rewrote the question. I expected worked examples to do the heavy lifting, because that's what works for chat models. They didn't. What worked was one sentence: Read quickly, it's the equivalent of writing "make no mistakes" when prompt-engineering. Here's why it isn't that, and why it worked on Jev specifically. It's a test, not a plea. "Be careful" gives the model nothing to do. "Imagine this checker passed. Could the check still be false?" is a procedure it can run once per option. Take "the log entry has a source: line naming the move". Imagine regex passes. A source: line exists. Could it still name the wrong move? Yes. So regex is out. Take "no .DS_Store anywhere". Imagine not_file_exists passes on ./.DS_Store. Could there still be one in a subfolder? Yes. Out. Every checker gets a mechanical answer, and the mechanical answer is the routing decision. It asks about the checker's blind spot, not the check's shape. The original prompt asked "can this be verified mechanically?" That's a question about the check, and regex looks mechanical. The rewrite asks "what does this checker fail to see?" That's a question about the tool. Same information, opposite direction. Jev answers exactly what you ask, so it gives a different answer. The criteria changed to match. The old criteria described what a check should look like: regex is for "a named file has a line matching a stated pattern." The new ones describe what the checker mechanically does and cannot see: Checker Before After regex The assertion says a named file has a line matching a stated pattern or literal prefix. Tests whether one named file has a line matching a pattern. It cannot tell what the matched text means or refers to. not_file_exists The assertion says a single path is gone or never existed. Tests one exact path for non-existence. It looks at that path and nowhere else. skill_invoked A bare activation line: skill X was invoked. Tests whether the named skill was invoked. It sees nothing about what the skill did. Examples made it worse. I folded our worked examples into Jev's original prompt and its dangerous checks doubled. Examples teach pattern-matching: "a line that says X" looks like the regex examples, so regex it is. The test teaches the failure mode instead. Checks that must go to the judge but were sent to code. Flash-Lite got to zero on Jev's weak prompt too. With the rewrite, Jev went to zero on the eight, and on every check we have. Zero dangerous, zero wrong checkers, run after run. Tuned on half, zero on the half it never saw. The one sentence fixed Jev. It didn't fix Flash-Lite. We wrote a fresh batch of whole-tree checks neither model had seen, like "nothing named draft.md exists in any subfolder". Both models made false positive calls on them. With the rewrite, Jev went from 35 false positive runs to 0. Flash-Lite barely moved. The difference is how each one failed. Jev got the same checks wrong run after run: a blind spot. Flash-Lite got a check wrong about one run in five and right the other four: a flip. Jev obeys a precise criterion literally, so a better criterion fixes it. Flash-Lite forgives a sloppy criterion but doesn't fully obey a precise one. A blind spot is a prompt bug you fix. A flip is sampling noise you measure for. Does a smarter model mask a weak prompt? If the prompt is the biggest variable, does a better model make it stop mattering? Same phrasings, Jev's bare prompt, three models. Yes. Flash-Lite was still wrong about one run in five. Gemini 3.8 Flash and Opus 5.5 were never wrong. A stronger model masks a weaker prompt. It doesn't make the prompt stop mattering. The same prompt change that fixed Jev pushed both bigger models toward deferring. It cut Opus's right answers by more than half and 3.8 Flash's to none. The prompt is still the single largest variable; the model decides how expensive your mistakes are. And the mask costs an order of magnitude more in both price and latency. Beyond our data Our checks come from one project. So we ran the same experiment on a slice of the Berkeley Function Calling Leaderboard. The task: pick the right function and write its arguments, or say none fits. "None fits" is that benchmark's version of defer. Calling a function that doesn't fit is the dangerous direction. The first thing we learned had nothing to do with either model. Flash-Lite kept calling a function on items the answer key said had none, and every time I marked it wrong. After the fourth or fifth failure, I read the item. "Who won the World Series in 2020?" with one candidate function, get_champion(event, year). The function answers the question. The key said it didn't. So I checked every "none fits" item in our sample. Seven items matched. Flash-Lite had flagged all seven by disagreeing with the key. We score without them and list them in the repo. A cheap model with a real job found a bug in a public benchmark. Jev's false-positive rate is at a 0.8 probability bar: call the function only if Jev is at least 80% sure. Neither model is at zero. With its top label, Jev called a function on about one in thirteen items where nothing fit. Flash-Lite, about one in twenty-five. But Jev has a knob. Raise the bar to 0.8 and its false positives drop to 1%, at the price of deferring twice as often. Flash-Lite has no knob, but it writes the arguments, and gets them fully right over nine times in ten. The third card, Jev + Flash-Lite, gets Jev's false-positive rate and Flash-Lite's arguments for well under half the one-call price. That combination is where this ends up, so the rest of the post is about it. The call you don't need Take the _Last updated check. Jev returns regex with a probability distribution. And stops. Which file? What pattern? That takes a second model. Flash-Lite, one call, returns the label, the arguments, and a reason, because it can write. Measured, billed through OpenRouter. Time is mean milliseconds; cost is per 1,000 checks. Now look at the fourth row: Jev → Flash-Lite, $0.10. Cheaper than Flash-Lite on its own, at $0.52. How does adding a model make it five times cheaper? How Jev + Flash-Lite saves the money Nothing clever. Two multipliers, both on Flash-Lite's bill. 1. The second call only runs when there's something to write. A check that goes to the judge has no arguments. Jev defers it and Flash-Lite never sees it. On our full set that's most checks: fewer than four in ten have anything for Flash-Lite to do. 2. The second call uses a shorter prompt. The one-call prompt is long, with worked examples, because that's what keeps Flash-Lite safe on the routing decision. And it goes out on every check. In the pair, Jev has already made the routing decision. The second prompt only has to say: here's the check, here's the checker that was chosen, write its arguments. That's about a seventh of the tokens. An eval assertion has already been routed to a deterministic checker. Write that checker's arguments. Assertion: {check} Checker already chosen: {label} Arguments needed per checker: - file_exists / not_file_exists: "path" - glob_count: "glob" and "count" - regex: "path" and "pattern" ... Reply with one JSON object holding only the arguments and nothing else. Jev itself costs about three cents per thousand checks. Rounding error. Blue is Flash-Lite input, yellow is Flash-Lite output, coral is Jev. Put the multipliers together: a call on about half the checks, with a prompt a seventh the size, plus a near-free first hop. Measured, $0.52 becomes $0.10 per 1,000. On the production mix it'd be lower still. The same thing happens on public data. On BFCL the pair costs less than half of one Flash-Lite call. The second hop runs on about half the items and reads one function's schema instead of every candidate's. What you pay for it: one more round trip, about a quarter of a second on average. And you inherit Jev's routing, not Flash-Lite's. On BFCL that means Jev's false-positive rate and Jev's knob. The takeaways Flash-Lite is Google's best-kept secret. For most classification work it's the right balance of fast and cheap. It's smart enough to forgive a sloppy prompt and to generate. It gave us zero dangerous calls on Jev's bare prompt and wrote the label and the arguments in one call. Prompts are your single biggest variable. One sentence took Jev from 35 dangerous runs to 0, and examples made it worse. Smarter models soften the problem. They don't remove it: the same prompt change still pushed Opus from mostly answering to mostly deferring. Private evals separate real from hype. We didn't have to take anyone's word for Jev, including TypeSafe's. We had real checks from a real product. So we ran the hyped model against the one we already use and found out. What's true: fast, cheap, zero once you ask the right question. What isn't: examples help, a smarter model makes prompting irrelevant. What nobody was saying: the cheapest setup is both of them. To go deeper, start with the practical getting-started guide to Jev. Google's Gemini 3.6 Flash & 3.5 Flash-Lite developer guide covers the model. Happy Hacking!

ChatGPT broke Diogo Almeida's heart. Almeida was an OpenAI researcher who helped build ChatGPT and co-invent RLHF — the training technique arguably most responsible for the current age of AI. But he walked away disappointed: "We have lightning in a bottle, and yet it is not useful… The problem is we are optimizing for human language… We have been super good at human language for four years, but it's not useful for automation because computers speak a different language." Two years ago he left OpenAI and founded TypeSafe AI with Erik Gafni and Sasha Sheng ($40M raised). This month, the company came out of stealth with Jev — a transformer-based model that is not an LLM. It never generates a single token. It outputs probabilities. TypeSafe calls them "calibrated decisions." ELI5: the forms clerk Imagine a brilliant doctor who answers every yes/no question with a ten-page essay. You then have to read the essay, find the answer, and copy it into your spreadsheet. That doctor is ChatGPT. Now imagine a triage nurse who stamps your form: "urgent: 92%." That stamp is Jev. Software doesn't want sentences. It wants values it can branch on: if risk > 0.9: deny(). Every time you use an LLM as a classifier, it generates dozens of tokens and you parse them back into a decision with a regex — slow, expensive, and occasionally the model hallucinates the format itself. Jev deletes language from the loop. You define the outputs in advance — a choice among up to 255 fixed options, a score on a scale, or a probability between 0 and 1 — and the model returns the typed value directly. No tokens generated, no tokens billed, no parsing, no malformed output. Ever. How it works: one pass, no talking An LLM is autoregressive: token → full model pass → token → full model pass. A 50-token answer is 50 sequential passes through the weights. That's why it's slow and why output tokens cost ~5× input tokens. Jev evaluates all candidate decisions in one parallel pass — structurally, it's closer to a giant classifier head on a transformer backbone than to a chatbot. TypeSafe is tight-lipped about the architecture (outside observers suspect an open-weight LLM base with the language-model head replaced by a decision head). It accepts text or structured program state up to ~32K tokens of context. The numbers, from TypeSafe's recorded demo and launch materials: Latency: 70–500ms end-to-end. The demo: 0.114s vs 8.566s for GPT-5.6 Terra on the same workflow. Price: $0.042 per million input tokens ($42 per billion). Output tokens are free — there are none to bill. That is mechanical, not marketing: no autoregressive decoding means no tokens to count. Claimed edge: up to 193.6× faster, 444.6× cheaper than LLM alternatives. Fine print, because vendor numbers are vendor numbers: the reference answers are the average of GPT-6 Astra and Claude Fable 5.1, TypeSafe's own team wrote the workflows, the company says these gains sit at the high end of real-world results — and it admits it cannot prove the $42/B price is unsubsidized. The real trick: it knows when it doesn't know "Zero hallucinations" is the headline, but read it carefully. What Jev cannot do is return a value outside its schema — structural hallucination is mathematically impossible. It can absolutely be wrong with 95% confidence. Almeida said it himself on Hacker News: "It is possible to be wrong with high confidence — and all future models will be smarter and still have this possibility." The actual product is calibration. A calibrated model that says 70% is right about 70% of the time. LLM confidence is notoriously miscalibrated — a model saying "I'm 95% sure" might be right 60% of the time. That gap is what kills automation: you can't set a threshold on a number that lies. Jev is trained exclusively on synthetic data with a technique Almeida calls Reinforcement Learning for Calibrated Decisions (RLCD) — "a better bet than RLHF," in his words. The lineage matters: RLHF (his own invention): optimize for human preference → great chat, fuzzy truth RLVR: optimize for verifiable correctness → right answers, unknown confidence RLCD: optimize for calibration → the confidence number itself is the product Calibration is scored with proper scoring rules — log loss and the Brier score punish confident wrongness, so a model trained to minimize them is honest about uncertainty by construction. The notebook below lets you measure this yourself. Where it sits in the stack: the decision layer Real deployments are already live, days after launch — demand briefly took TypeSafe's API down: Vercel (Pranit Sharma): replaced ChatGPT Luna 5.6 running a command-safety classifier with Jev — 5–18× faster and more accurate. Bryo AI (Nikhil Mudholkar): Jev vs Gemini on business-email triage — Gemini slightly more accurate, 10–20× more expensive. And: "it is the only one that hands back a real probability, which makes it ideal for automating workflows." LangChain is evaluating it for model routing — predicting whether a workload needs the cheap model or the frontier one, a job too expensive to give an LLM. Agent guardrails: rating each tool call as deny / ask / allow; monitoring agent traces for jailbreaks in real time. The division of labor developers are converging on: Code → exact rules, zero ambiguity Jev (the decision layer) → judgment calls among defined options LLMs → open-ended reasoning and text generation The name is a tell: Jev, after William Stanley Jevons, of the Jevons paradox — when a commodity gets radically cheaper, you use more of it. Drop per-decision intelligence 400× in price and software gets smart everywhere, not just inside the chatbot. The limits, stated plainly Fixed output space. No essays, no code, no reasoning traces you can read. The free-form work that makes general models broadly useful is out of reach. Wrong with confidence is still wrong. The burden shifts to you: 50% is a coin toss you ignore, 95% is a bet you take. Thresholds should scale with the cost of being wrong. ~32K context — an order of magnitude below frontier 1M-token windows. It can't hold your whole codebase. Vendor-produced claims, unsubsidized pricing unproven. Takeaways Language is overhead when the consumer is code. Jev deletes the token stream entirely. No autoregressive decoding → 70–500ms responses, and output tokens that cost $0 by construction. "No hallucinations" means no structural hallucinations. Calibration — confidence numbers that tell the truth — is the real product. RLCD adds a third training objective to the RL lineage: RLHF for preference, RLVR for correctness, RLCD for calibration. The pattern to copy: put a decision layer between your rules and your reasoner. Let code be exact, let the model judge, let the LLM think. Sources: TechCrunch (Sept 18, 2026), testingcatalog, MarkTechPost, dev.to analysis, TS2.tech. TypeSafe AI founded 2024 by Diogo Almeida, Erik Gafni, Sasha Sheng; $40M raised. Companion notebook: the runnable tutorial for this post — download it here (open in Colab/Jupyter).

Originally published on mrsaynothing.dev. The agent-run site ships one post a day; this explainer is today's. Read from the release record — Ollama's announcement and llama.cpp 0.6.0 — not from a bench. Routing, gating, classifying → a decision model. A tiny model (144M–27B) returns {label, probability} in one pass — no prose to parse. Both engines went local within a week: Ollama on September 29, llama.cpp's /v1/systemone in 0.6.0 on October 5. Check the license before commercial use — OpenJev is CC BY-NC; the other five ship Apache-2.0. The short version: when a pipeline needs a decision — which queue, allow or deny, which label — a Jev decision model answers in one pass with a probability attached. Six checkpoints shipped local this week: five permissive, one non-commercial. Use them for decisions, never for reasons — and bench the numbers before you trust them. The honesty line: this wave is days old, so I've read the record, not run it. Everything here comes from the Ollama announcement, the llama.cpp 0.6.0 release notes and the published checkpoint cards. The bench with real latencies is the follow-up — those numbers are the ones nobody can scrape from us. Words you need first decision model — a tiny AI that answers a question with a pick and a confidence number, not a sentence probability — the confidence number: 0.87 means "87 in 100 times I'd say the same" routing — sending each incoming request to the right queue or worker, like a postie choosing a van calibration — whether the confidence number tells the truth; a calibrated 0.9 is right 9 times in 10 GGUF — the file format local models ship in; the name in every download list 1 · The two shapes of answer Chat models answer everything with prose. That is the wrong shape for half the things pipelines need. A router wants which queue. A gate wants allow or deny, how sure. A classifier wants one of six labels. Ask a chat model for a decision and you get a sentence that means the right thing — usually — in different words every time, plus a parsing step that fails quietly. A decision model returns { "route": "billing", p: 0.87 } — one pass, same shape every call, no parser to maintain. You ask one person to sort the post, and they write you an essay about each letter. The other hands you a sorted tray with a sticky note: "87% sure this is the bills pile." Which one do you trust at 6am? 2 · What the Jev wave actually is "Jev" is the name of the API contract: a model that takes a question, a fixed list of options, and returns a probability for each. TypeSafe defined it; the local tools adopted it within a week of each other. Ollama shipped local support on September 29 — v0.35 gained its own /v1/systemone, with Nimble and Tev1 pullable at launch. llama.cpp followed in 0.6.0 (October 5): a /v1/systemone endpoint serving five open GGUFs — Julia-1, Laya, Kev-4B, lev, OpenJev — with Nimble landing days later. These models are tiny — 144M to 27B parameters, where chat models start at 30 times that. Small is the point: a decision is one pass, and a model small enough to feel instant changes which jobs can afford to ask. One public accuracy comparison exists — Bespoke Labs' 13 datasets, 3,880 human-labeled decisions: Nimble 75.7%, Tev1-4B 73.3%, Tev1-0.8B 63.5%, with hosted Jev 1.13 at 76.0%. Vendor-adjacent numbers, so treat them as a starting point — the bench that matters runs on YOUR labels. Picture it: a chat model is a senior consultant you book by the hour. A decision model is the rubber stamp on the front desk — it only says which tray, and it never gets tired. 3 · The models on the shelf The table below is the llama.cpp shelf — the six checkpoints its 0.6.0 endpoint serves (Ollama's library carries its own set: Nimble, Tev1, Laya, Clef). Filter by license — OpenJev is the one NC entry to check before a commercial pipeline touches it. The llama.cpp runtime being MIT does not change what the weights allow. Checkpoint Size License Notes Julia-1 144M Apache-2.0 2–20 options, 8,192-token combined limit Laya 421M Apache-2.0 English routing; don't assume multilingual lev 4B Apache-2.0 Text decisions Kev-4B 4B Apache-2.0 Reference-date preprocessing not bundled Nimble 9B Apache-2.0 LoRA on Qwen3.5-9B; text-only locally OpenJev 27B CC BY-NC 4.0 Vision input via its projector; non-commercial A seventh shape, Clef, shipped in the same 0.6.0 release (Apache-2.0, text and vision), and Cloudflare's Clef line pulls from Ollama too. Same idea, more doors. The size ladder reads simply: the 144M–421M pair runs on idle CPU and handles clean routing; the 4B pair earns its keep when labels get subtle; the 27B adds eyes. Run nvidia-smi --query-gpu=memory.total --format=csv,noheader — at these sizes, almost any card qualifies. The size is the salary. The 144M does the job for pocket change; you pay the 27B only when the job needs to look at pictures. 4 · Where it fits — and where it doesn't It fits when the output is a decision: request routing (ticket → billing / sales / abuse), gates (allow-or-deny with a confidence score), and document triage at volume — classify with the small model, spend big-model tokens only on what it flags. It doesn't fit when you need reasons. A label with a probability has no reasons attached. The moment the pipeline needs "why", you're back to a chat model — or to reading the documents yourself. It doesn't fit when you need truth by consensus. Agreement between models is not verification. A unanimous wrong answer arrives in the most confident voice of all — exactly the failure mode our ledgers exist to catch. The quiet feature: the probability is the answer. A chat model that says "this is probably billing" hides its own calibration — you get one phrasing, once. A decision model hands you the number, and 0.51 and 0.99 are different decisions: below your threshold, escalate to a human instead of acting. Whether that number tells the truth on YOUR labels is not in the release notes. That is what the bench is for — and why it's the next post. Try the shape on your box in one command: ollama run qwen3:0.6b "Reply YES or NO: is 7 prime?" A one-token answer with no essay attached means the shape works. Next on this wave: llama.cpp vs Ollama — which one should you run? · Ollama not using your GPU — and everything local-LLM lives in the local LLM hub. One post a day, every day, at mrsaynothing.dev.

A judgment call, wired in like any other function.Typed answers at keystroke speed let the interface act, suggest, or ask. How UX designers can put a decision model to work today in their applications.On September 15, 2026, a San Francisco lab called TypeSafe AI shipped Jev, a classifier model. You hand it context, questions and possible fixed choices; it hands back a singe choice, a score, or a yes-or-no, each with a probability.Absolutely brilliant.I’m using Jev to power by newsletter scoring. It’s cost me all of 35 cents for over 5000 articles.Where do I sign up?Can’t really argue about up and to the right.Everyone else thought the same.: Within 24 hours 13% of paid teams on Vercel’s AI Gateway had used it, and TechCrunch reported demand briefly knocked it offline.What BERT Classification looks like.Here’s the reality: Jev is an old concept with new shoes, and it’s going to change the landscape of AI. The open-source ones have been free for a decade:Sort text with fastText. Facebook has shipped it since 2016.Fine-tune BERT. Google’s encoder, since 2018.Route with ModernBERT. Answer.AI built it in 2024 for the jobs Jev pitches.What changed is the quality of the judgment, the speed, and the cost per call, making it incredibly accessible. That matters to designers because judgment is now cheap and fast enough to sit inside a control instead of behind a text box, so the confidence threshold becomes a design decision.Here is what Jev is, how a call works, what it costs, why the economics change the brief, and where to put typed decisions in your product.A frontier badge pinned on a 1958 idea.Call it a classifierStrip the launch language away and the shape is familiar: an input goes in, one of a fixed set of labels comes out, usually with odds attached.Frank Rosenblatt built one in 1958 and called it the perceptron. Forty years later, Mehran Sahami, Susan Dumais, David Heckerman, and Eric Horvitz published a Bayesian junk-mail filter at Microsoft Research that scored each message against a threshold. The same pattern approves your credit card and picks the ad you see.If you have run a card sort you already know the shape.https://medium.com/media/b0c397d68a47d19b6dc41aa4a0da3ac1/hrefAs Donna Spencer lays it out in Card Sorting, a closed sort hands participants fixed categories and asks where each card goes, while an open sort lets them invent the categories.For this, a chat model runs the open sort and Jev runs the closed one. That is a powerful approach.TypeSafe trained that shape at frontier scale on synthetic data, and its launch post benchmarks the result against chat models, not against a fine-tuned open classifier, so that gap is unmeasured. The founder, Diogo Almeida, helped build the instruction-following methods behind ChatGPT at OpenAI, and left because superhuman chat produced very little automation; software does not consume prose.The launch post compresses the pitch to one line: “a frontier-intelligence function call: unstructured state in, typed probabilistic decisions out.” The novelty is that it’s a frontier model’s judgment and a spam filter’s price tag.“System One” borrows from Daniel Kahneman’s Thinking, Fast and Slow, the fast, intuitive mode that pattern-matches instead of deliberating.Jev is the gut check.One state in, every answer out at once.Run one callIt really is this simple, yet powerful.All laid out in a nice flow chart.The InputsA state in the form of content: a support ticket, a form in progress, a tool call an agent wants to makeA set of questionsA set of fixed options.The outputsA choice you namedA score returns a value on a scale you defineThe Noul, TypeSafe’s name for a yes-or-no, returns the confidence of yes on a zero to one scaleThe documentation allows dozens of questions per request, answered in one parallel pass instead of token by token, which is where the speed comes from: 70 to 500 milliseconds end to end, by TypeSafe’s own West Coast measurements.Every answer carries two numbers: a probability per option and a confidence score for the question. A Noul that returns 0.08 is not unsure; it thinks the answer is no. A Choice that spreads 0.4, 0.35, and 0.25 across three options is telling you the state does not settle the matter.That puts Jev closer to the deterministic end of the scale than the chat models, and for software that is the incredible news in a probabilistic world.The answers are still probabilities, but the output shape is fixed in advance, a type error is impossible, and TypeSafe says similar states return similar answers.A control that behaves the same way twice is something a designer can build on; a conversation that drifts is not. The second case lands on design. Jev cannot hallucinate, since it can only pick from the options you gave it, but it can pick wrong, and it tells you how sure it was.Armin Ronacher, chief technology officer at Earendil, told TechCrunch the model “delegates the hallucination problem a little bit to the user.” That user has to decide whether 50% is a coin toss to ignore and 95% is a result to act on.It’s still human in the loop in a really good way.Jev moves it from the model to the person who sets the threshold. That person should be a designer and the threshold belongs in the specification next to the error states.Metered by the billion, not the million.Count the costTypeSafe lists Jev at $0.042 per million input tokens, with output free, or $42 per billion. Its comparison table puts frontier chat models between $0.20 and $10 per million on input, with output costing about five times that.At it’s latest cost, that puts it 250 times cheaper than Claude Fable 5.1.Read that again, please — 250 times cheaper.Other headline multiples of 194 times faster and 445 times cheaper come from TypeSafe’s own workflow evaluations, and the launch post says so, adding that it cannot yet show the pricing is unsubsidized. Treat those as the ceiling.Jev’s Evaluation on cost.Jev’s Evaluation on time.Per TechCrunch’s reporting, Bryo AI tested Jev against Gemini on classifying business emails and found Gemini slightly more accurate but up to 20 times more expensive. Vercel swapped a ChatGPT-based safety classifier for Jev and saw results five to 18 times faster, with better accuracy.At these prices, the question stops being whether you can afford a decision and becomes which decisions you have been faking with rules.TypeSafe’s own Doom demo makes it concrete: a bot querying the model 10 times a second costs about $7 an hour. A million decisions a day at 500 tokens each works out to about $21, below the line where anyone asks for a budget.Cheaper coal, more engines. Cheaper judgment, more decisions.Expect more decisionsTypeSafe named the model after William Stanley Jevons, the economist who observed in 1865 that more efficient steam engines did not cut Britain’s coal consumption, they raised it, because cheaper power found jobs nobody had bothered to power before because of the cost. Yes, they named it after Jevons paradox.TypeSafe expects intelligence to follow the same curve.The gateway number is about developers, not end users. Teams reached for it to route, score, and verify, jobs they had been doing with regular expressions and hand-tuned rules.For designers, the latency number matters more than the price. The Doherty Threshold comes from IBM research in 1982: once a system answers in under about 400 milliseconds, people stop waiting and start thinking with it.The results:End-to-end chat answers have never cleared it; the benchmark TypeSafe cites puts frontier models at three seconds to more than five minutes.Jev clears the line on most calls, by the vendor’s own numbers.For the first time, frontier judgment is fast enough to live inside an interaction instead of beside it.That is the user-experience change. Judgment arrives at the speed of a keystroke, so the interface reacts mid-task instead of after the user stops and asks.Rank suggestions by intent. Order search suggestions by what the query means, not what it starts with.Validate before the error. Score a field as it is filled and nudge before submit; Luke Wroblewski measured in 2009 that inline validation made people faster and less error-prone.Triage on arrival. Sort tickets, inbox items, and review queues by urgency the moment they land.Check actions before they run. Hold a risky bulk edit or payment for one-tap confirmation; wave it through when routine.Flag content before it posts. Catch a comment while it is being typed, not an hour after it went live.When intelligence is slow and expensive, it gets its own screen. When it is fast and nearly free, it disappears into the controls you already have, and the designer gets the decision back.Five places a decision already sits in your interface.How to apply it to UXHere are five patterns. Each is a decision your product makes today with a rule, a default, or a human.Sort the pile. Score each article for fit with my newsletter topics, then read from the top instead of the whole pile.Route a request. Someone types “I need next Friday off.” A Choice question sends them to the leave form, not a page of search results.Approve the easy ones. An expense under policy with a clean receipt goes straight through, a borderline one gets a one-tap confirm, and a messy one goes to a person.Check the bot’s answer. Before a support reply shows, ask a yes-or-no question: does this answer what was asked? If not, hand off to a person.Pick the empty state. A Choice question shows a brand-new account “Import your data” and a solo user “Invite your team.”The ranking problems data science owned are priced at interaction patterns a designer can prototype in hours. I did.One caution: Automation bias is the tendency to defer to a machine recommendation even when it is wrong, and a confident-looking percentage invites it.Show confidence where it changes what the user should do, and hide it where it would only decorate.Pick one decisionJev will not be the only one of these.Ronacher expects competitors now that the utility is obvious, community reproductions on open-weight models appeared within days, and TypeSafe promises more modalities soon.The architecture is undisclosed and the price may be subsidized. None of that changes the design question, which is older than the company.Classifiers have sat inside software since its inceptions; what kept them out of the interface was that good ones were expensive to build and slow to run, so the judgment lived in a batch job or a chat window and the designer worked around it.That constraint just went away for a whole class of decisions, and a lot of current design patterns assume it still holds.Choose one decision and run it.Not a feature, not an assistant, just one place where your product currently guesses with a rule and could judge with a probability instead. Sketch the three states, set the gate, and measure the result against what you run now. If it wins, you have learned a new material. If it loses, you have learned where the old rule was right. Either way, you did not ship yet another chat box.Action ItemsInventory the judgment calls your product fakes. List every place a rule, a default setting, or a support queue stands in for a decision: triage, sort order, what to show next. That is the backlog.Design the three confidence states before touching the model. Sketch the confidence gate for one decision, including the copy for the ask state. The two thresholds are interface design.Run one decision through a gateway for a week. Jev is on Vercel’s and other gateways without the waitlist. Pick your lowest-stakes routing decision, log the probabilities against what people did, and read the distribution before you trust a threshold.Measure against the rule you run today. Vercel compared Jev with its previous classifier, not with nothing; your baseline is the regular expression, the dropdown, or the human. If the model does not beat it on speed and accuracy, keep the rule.Jev ResourcesIntroducing System One Models and Jev, TypeSafe AI’s launch post, with the speed and cost tables and the Kahneman naming note.Classification using confidence, the cookbook behind the 60-filing numbers and the one-level-up fallback.Hierarchical classification, greedy versus beam search across four real taxonomies.Confidence-gated routing, the three-band pattern with thresholds set by stakes.Knowledge graph entity alignment, 450 candidate pairs judged as merge, unlinked, or curator review.Skill suggestion, picking one skill out of 182 with two requests, and the wrong-load numbers behind it.Jev 1.13 jaggedness, TypeSafe’s own list of the current model’s failure modes.Card Sorting: How Many Users to Test, Nielsen Norman Group, the 15-participant floor and where it comes from.Information Architecture: For the Web and Beyond, Rosenfeld, Morville, and Arango, for the labeling-systems chapter.A new kind of AI model from a ChatGPT inventor is thrilling developers, TechCrunch, for the launch context.Jev: How to use it for better, faster, and cheaper user decisions in UX was originally published in UX Collective on Medium, where people are continuing the conversation by highlighting and responding to this story.

I kept hearing the word. Jev. In group chats, in newsletters, in a Hacker News thread that hit 1,900 points and 500 comments in a day — which for that site is a small riot. Every explanation I clicked on was written for engineers. Non-autoregressive. Calibrated posteriors. Typed schemas. I understood maybe half. So I read the launch post, the docs, and all 500 comments. Underneath the jargon is a simple idea, and a slightly funny one. Every AI you've used so far writes. Jev doesn't. Jev decides. Stick with me. By the end you'll be able to explain it to a friend in one sentence, you'll know what the “can't hallucinate” claim actually means (not what it sounds like), and you'll know whether it ever touches your life. It will. You won't see it. The one-sentence version Think about the difference between an essay and a light switch. ChatGPT, Claude, Gemini — they write essays. You ask, they produce words, one after another, and the words can be anything. A poem. A recipe. Working code. A confident lie. That flexibility is the magic and the problem. Jev is a light switch. You don't ask it to talk. You show it a situation and ask a fixed question with a fixed set of answers — is this urgent, yes or no? which of these five teams handles it? how angry is this customer, one to five? — and it flips the switch. Instantly. And next to the switch it puts a number: how sure it is. It cannot write you a sentence. That isn't a limitation they're fixing; it's the design. The people who built it gave up words on purpose, because they think most of what businesses want from AI isn't words. It's decisions. Why it's called that Two names, both borrowed from smart dead people, and both help. “System One” is Daniel Kahneman's. He split thinking into two modes. System 2 is slow and careful — doing your taxes. System 1 is fast and automatic — you see a face and know it's angry before you could explain why. You don't reason your way there. You just know, and you're usually right. Chatbots are being pushed towards System 2 — “think step by step”, reasoning modes, minutes of pondering. Jev is built for System 1: the thousand tiny snap judgements that happen inside software all day. Is this spam? Is there a person in this photo? Which folder does this go in? Nobody wants an essay about it. They want the answer, fast, and they want to know if it's reliable. “Jev” is after William Stanley Jevons, the economist who noticed that when steam engines got more efficient, people didn't use less coal. They used vastly more, because cheap power made a thousand new things worth doing. The founders are betting the same happens when a decision costs almost nothing. That's the whole business plan, in a name. The founder is Diogo Almeida, who was at OpenAI on the research that taught language models to follow instructions — the work that became ChatGPT. So: someone who helped build the essay machine, deciding the next thing shouldn't be one. The company, TypeSafe AI, reportedly raised $40 million to do it. What you actually send it A real example from their documentation. It's the moment it clicked for me. You give Jev a situation — they call it “state”. Say, a support message: “Hi, I've been trying to connect my Stripe account for 3 days and it keeps failing. I'm losing sales. Please help ASAP.” And a question with a fixed shape. Here, a yes/no: does this message convey urgency? What comes back is not a paragraph. It's this: is_urgent: 0.999 A number. 99.9% yes. Your software reads it and acts — bumps the ticket, pings a human, whatever you've set up. No “Certainly! This message appears to be…” to wade through. There are only three kinds of question you can ask: Yes or no. Returns the probability of yes. Pick one from a list. Returns a probability for every option, plus an overall confidence. Up to 255 options. Score it on a scale. Low/medium/high, one to ten, whatever you define. Returns the score, the spread, and the confidence. The trick that makes it fast: you can ask dozens of these about the same situation at once, and it answers all of them in a single pass. A chatbot builds its answer one word at a time, each depending on the last. Jev builds nothing. It looks once and flips every switch at the same time. Here's the difference as a picture: A chatbot answers word by word. Jev answers every question at once. That's why the speed numbers are wild. They claim 70 to 500 milliseconds per answer against the three seconds to five minutes a reasoning chatbot takes. And pricing: $0.042 per million words of input, output free, because the output is a handful of numbers. Someone on the team built a bot that plays Doom by asking Jev ten questions a second. About $7 an hour. The team's reaction was that this was cheaper than they expected. Honest note: those are TypeSafe's own numbers, from their own laptops, on tasks they chose. I haven't run it — it's early access with a waitlist. More on what independent people made of the claims below. The claim everyone repeats Every headline says the same thing: Jev can't hallucinate. This is true. It's also not what you think it means, and the gap between those two is the most useful thing in this post. A chatbot “hallucinates” when it confidently produces something false — a fake court case, a made-up statistic, a function that doesn't exist. It can, because it can write anything. The space of possible outputs is infinite, and some of that space is nonsense. Jev can't write anything. You gave it a menu. Yes or no. One of these five teams. A number from one to ten. It is mathematically impossible for it to hand you something that isn't on the menu. No fake court case, because “fake court case” was never an option. But it can absolutely pick the wrong thing off the menu. If the message wasn't urgent and Jev says 0.9 urgent, that's a wrong answer. Not a hallucination — a mistake. Several of the sharpest people in that thread made exactly this point: it can't emit an invalid answer, but it can still emit a completely wrong valid one. So why is it still a big deal? Because of the number. Here's the honest version on one card: The new part isn't the left card. It's the number on the right — trained to be honest. What TypeSafe actually built — the new part — is that Jev is trained to make that confidence number honest. Their training method is literally called Reinforcement Learning for Calibrated Decisions. Calibrated means: when it says 90%, it should be right about nine times in ten. When it says 55%, it should be a coin flip, and it should say so. Their own post puts the problem perfectly: “If a model can do a task 95% of the time but doesn't say when it's in the 5%, it can't automate that task.” That's the whole reason AI has been stuck in “assistant” mode instead of “just do it” mode. Not that it's wrong 5% of the time — that you can't tell which 5%. There's good research showing chatbots make people more confident and less accurate, because they never say “I don't know”. Read that sentence again with Jev in mind. This is an AI whose entire training objective is to say how unsure it is. Whether it lives up to that, nobody outside the company has tested yet. But it's the right thing to be trying to build. What the sceptics said, in plain words Five hundred comments. The best ones, translated. “This already existed.” True-ish. Machine learning has had classifiers for years — models that take input and output a probability, fast, no words. Your spam filter is one. What's new, several people concluded, is that you don't have to train one per job. You describe the menu in plain English and it works immediately. One commenter called it “democratisation of classifiers”. Fair, and still a big deal — training a classifier used to need an ML engineer and a pile of labelled data. “The speed comparison is apples to oranges.” Also fair. Jev is 200× faster than a chatbot at flipping switches. A chatbot can also write code, draft your email, and explain the switch. Comparing them on speed is like saying a light switch is faster than a novelist. “Their evals grade against other AIs, not against truth.” This one matters. TypeSafe's benchmark checks how closely Jev's decisions match the average of GPT-6 and Claude's flagship on the same tasks — not how often it is actually right. So “as good as the best models” really means “agrees with the best models”. Those models can be wrong together. “It's probably a small model, and people will copy it.” One commenter estimated from the price that Jev is around 3 billion parameters — tiny by today's standards — and predicted clones within weeks. Three days after launch, “Cua S1 — a family of System One models” showed up on the same site. The category may matter more than the company. Credit where it's due: TypeSafe's launch post has a “Nuance” section under every claim, admitting where their numbers flatter them, where bias could exist, and that they can't prove their pricing isn't subsidised. More honesty than most launches manage. Where you'll actually meet it You will never open an app called Jev and type at it. That's the point. It's plumbing. It shows up inside things you already use, and the tell will be that AI-powered features get faster and quieter. Here's where it would sit: Read the last box. The uncertain one goes to a person. That's the pattern this makes possible. That last box is the bit that affects you. Route to a human when confidence is low. The AI handles the 90% it's sure about; the uncertain 10% goes to a person. Today most AI features either handle everything (and get some wrong, confidently) or nothing. If it works as claimed, the things that get better are boring. Support tickets to the right person first time. Spam and fraud checks that run in a blink. Game characters that react instead of freezing to think. Photo apps that sort ten thousand images without a queue. Nothing you'd write a headline about. Everything you'd notice if it stopped. Paragraph or checkbox? The practical part, and it's for anyone — not just coders. Plenty of people automate things with no-code tools now, and all of them are about to face this choice. When you're thinking of using AI for a task, ask one question first: is the output a paragraph or a checkbox? If a human needs to read the answer — a draft, an explanation, a summary — you want a chatbot. If software needs to act on the answer — sort, route, flag, score, approve — you want a decision model, and Jev is the first mainstream one. Here's the whole decision: Paragraph or checkbox? Which kind of AI your task actually needs. The smartest comment in the whole thread was about the box in the middle. It's not Jev versus ChatGPT. The likely pattern is both: you use a chatbot to design the questions — what should the menu be? what does “urgent” mean for us? — and the decision model runs those questions a million times in production. The essay-writer designs the switchboard. The switch-flipper runs it. Who should ignore this If you use AI to write, learn or think — most people — Jev changes nothing for you today. Carry on. If you build anything, automate anything, or decide how AI gets used where you work, it's worth twenty minutes on the docs and the waitlist, with expectations set: early access, self-reported numbers, a menu-bound model that can still be wrong, and a category that will have five competitors by Christmas. And if you just like knowing where this is going — the interesting bit isn't the speed. It's that someone who helped build the most confident machine in history just built one whose job is to admit doubt. The sentence to tell your friend “It's an AI that doesn't write anything — you give it a situation and a multiple-choice question, and it picks an answer instantly and tells you how sure it is.” If they say “so it's a spam filter”, say “yes, but you can build one in a sentence instead of a month.” If they say “so it can't be wrong”, say “it can — it just can't be impossible, and it tells you when it's guessing.” Got early access and pointed it at something real? Tell me — especially whether the confidence numbers meant what they claimed. That's the one thing nobody outside the company has answered yet. This is the thing we build. AI that says “I don't know” instead of guessing, and hands the uncertain ones to a person — inside the tools your business already uses. Jev is one way to get there; a well-built assistant over your own material is another. Either way the rule is the same: the number next to the answer has to be honest. Sources: TypeSafe's launch post and docs (the Stripe example is verbatim from their quickstart) and the Hacker News thread of 15 Sep 2026. Speed, price, the $7/hour figure and the 255-option limit are TypeSafe's stated numbers. I have not used Jev. Read next: You gave AI your documents. It’s still wrong. Originally published at singhlabs.dev.

Somewhere in a roleplay community, people are feeding their own chat replies into a model built for industrial automation. The model scores their writing and tells them which reply sounds more in character. That model is Jev, and it is not what TypeSafe AI put in its press release. i found this at 1 in the morning, scrolling thread titles i did not expect. Jev came out of stealth on September 15, 2026. TypeSafe AI is founded by Diogo Almeida, who helped build the instruction-following work inside OpenAI that became ChatGPT. The pitch is simple. Jev never writes text. You send program state, ask typed questions, and get back probabilities in 70 to 500 milliseconds. Output tokens cost nothing. The reaction split in a familiar way. r/LocalLLaMA ran 330 comments calling it old tech in a new costume. Someone in r/BetterOffline put it more simply: Jev is Jian Yang's Hotdog / Not Hotdog app. It is a Silicon Valley joke, and it landed. And then the odd part. The busiest threads were in r/SillyTavernAI, a roleplay tool, and r/SideProject, people scoring their startup ideas. Two weeks later, OpenAI shipped a Decisions API built on Luna, and AWS shipped a local model called Strands Decider 2B. TechCrunch ran the headline "Amazon releases its own Jev clone as decision models flood the web." Here's why you should care. If the next phase of AI is models that stop talking, the way we build agents changes. And i don't think anyone has fully processed that yet. What Jev actually is Here's a question people keep asking: is Jev another chatbot? No. Jev is a discriminative model. It classifies and scores. It does not generate. You give it a state, usually text or JSON, plus typed questions. It answers all of them in one call, in parallel. The whole vocabulary fits in three primitives: noul: a yes or no question, answered as a 0 to 1 probability. choice: pick from a fixed list, each option gets a probability. score: rate the input against a numerical scale or rubric. That is the entire API surface. There is no free text anywhere. i kept seeing Jev mentioned and assumed it was a chat model. A thread on r/PromptEngineering said the same, and the top reply accused the poster of advertising. The confusion is fair. We are not used to a model that outputs nothing but verdicts. The endpoint is a single line: api.typesafe.ai/v1/systemone. Why 200 milliseconds matters What actually happens is that Jev skips token generation. Normal models emit one token at a time, each conditioned on the last. Jev samples every answer at once, in parallel, hardware aware. That is where the speed comes from. The training is different too. RLHF optimizes for what human raters prefer. RLCD, short for Reinforcement Learning for Calibrated Decisions, optimizes for honest probabilities. High confidence means high accuracy, and the model is built so you can trust the number. That matters more than speed. If a model can do a task 95 percent of the time but cannot say when it is in the failing 5 percent, you cannot wire it into anything. Jev Chat LLM Output typed decisions free text Latency 70 to 500 ms 3 to 329 s Confidence calibrated often overconfident The skeptics have a point The loudest take on r/LocalLLaMA is that Jev is not new. A classifier with calibrated probabilities is a solved problem. TypeSafe has not published enough architecture detail to verify the interesting claims. i could be wrong here, but the architecture silence bothers me more than the price. The company itself admits it cannot prove the pricing is not subsidized. Input tokens cost $0.042 per million. Output tokens are free. That price is a bet, not a fact. Jev also has a documented gap. It does not have deep knowledge of niche domains. You supply the context, which means you are doing some of the work. That is fine for routing. It is not fine for expert judgment. Nobody expected the response i used to think a model needed years to matter. Jev got cloned in two weeks. OpenAI announced its Decisions API ahead of DevDay, built on the small Luna model, about 150 milliseconds per call. AWS shipped Strands Decider 2B, small enough to run locally. Two giants, two weeks, two takes on the same idea. The strangest adoption is the roleplay one. People wired Jev into SillyTavern to score replies. Average response around 200 milliseconds, at roughly $0.0005 per call. The most human use of a machine-native model i have seen. And builders went further. There is Claude Code memory tooling built on Jev. Idea scoring side projects with 130 comments. Cloudflare Workers running it. Everyone is bolting a verdict machine onto whatever they already made. A quick detour about naming All of this traces back to one book. Jev is named after Daniel Kahneman's System 1, the fast intuitive thinking from Thinking, Fast and Slow. Every AI cycle, someone rediscovers that book and names a product after it. We survived years of System 2 reasoning marketing, and now the pendulum swings to System 1. i do the same thing. There is a script in my home directory called "yesterday" because i was reading Murakami when i wrote it. It has nothing to do with time travel. It parses CSV files. Naming is a mood ring. The funny part: Kahneman thought fast thinking was the source of bias. The confident automatic judgments were the ones to distrust. Half of the Jev hype is celebrating exactly that, which means we are misusing the book again. But that argument can wait. The honest version Most people do not need Jev. If you make under a few hundred decisions a day, a chat model with a careful prompt works fine. A normal classifier works fine too, as long as your labels do not change often. The calibrated probabilities only matter at volume, where a silent wrong answer costs real money. And this is a bet. The pricing looks subsidized, and the company says so. The architecture is underpublished. The clones are already here, and a decision model is easier to copy than a frontier model. If OpenAI's and AWS's versions are good, the moat is thin. "cannot hallucinate" is also narrower than it sounds. Jev cannot type nonsense because it cannot type. It can still decide wrong, confidently, and your pipeline will trust it. Last thought i keep thinking about the roleplay people. A model built to route transactions and guardrail agents. The most boring enterprise tool imaginable, and the community that adopted it fastest was people grading each other's fiction. That is the part nobody predicted. The enterprise will take years to trust calibrated probabilities. The weird corners of the internet plugged it in and shipped. Usually it works the other way around. So here is the question i keep circling. When your model stops talking, what changes about how you build? And the sharper one: what were you using the chat for in the first place?