TypeSafe's Jev: The Decision Model Everyone Is Talking About

Four days ago almost nobody had heard of Jev. Today the launch thread has 27 million views, Hacker News has a 620+ point discussion, heated from the first hour, LangChain has already published an integration guide, and Vercel, OpenRouter, Netlify, and AIMLAPI all added it to their gateways within days. Vendors move that fast for exactly one reason: they smell a category.

So what is Jev, and is the hype deserved?

The smart if statement

Jev, from the new lab TypeSafe AI, is the least technical thing you can call it: a smart if statement.

An ordinary if branches on things a computer can check: if (order.total > 100). That works fine until the condition is a judgment. Is this support message angry? Which of these five tools should the agent call next? Does this email ask for a refund?

Today you handle those with an LLM: prompt it, get back a string (or JSON you hope matches your schema), parse it, retry when malformed. It works, but it's slow, costs real money, and still occasionally fails.

Jev removes the generation step. You send it a state — text or a JSON object — plus any number of typed questions, and it returns a probability for each question. A yes/no probability (they call it Noul), one option picked from a list you defined (Choice), or a position on a scale you described (Score). No prose, no parsing, no retries. Most calls complete in 70–500ms, typically around 100ms, and input tokens cost $0.042 per million with output billed free — responses do return output tokens, they just aren't metered.

What it isn't

The limitations are the product, not defects:

• It cannot write text — no replies, no summaries, no explanations, no code
• It cannot reason across multiple steps or explain its answers
• It only reads text — no images or audio
• A well-formed answer is guaranteed to fit your options, but a well-formed answer can still be wrong

The Kahneman framing explains the intent — and it's TypeSafe's own framing, which they call "System One models" to signal the class they claim to be founding. System 1 is fast, intuitive judgment; System 2 is slow, deliberate reasoning. Reasoning models handle System 2. Jev is built for the other half. The practical architecture is both together — Jev decides, the LLM writes when writing is needed.

The team behind it

The credibility is the story's engine. TypeSafe's founder Diogo Almeida worked on the RLHF and InstructGPT research at OpenAI — the direction that became ChatGPT, and the credential the company leads with. After two years in stealth, TypeSafe launched with a $40M seed led by DCVC and a new training method they call Reinforcement Learning for Calibrated Decisions (RLCD): instead of rewarding answers humans prefer, the model optimizes for probabilities that match outcomes.

Even the name is doing work: Jev is named after William Stanley Jevons, the economist behind the Jevons paradox — when steam engines got more efficient, coal consumption went up, because cheaper power created new uses. The bet is the same for inference: drop the cost of a decision to less than a fraction of a cent, and software will make thousands of tiny AI judgments that nobody would have called an LLM for.

The reception

The launch post came from Diogo's personal account on September 15, and the metrics were abnormal: 27.1M views, 63K likes, 52K bookmarks — ranked among the top 5 of 625 tracked product launches, more than 100x the median. Hacker News took over from there, split between genuine interest and sharp benchmarking debates.

Within 48 hours:

• LangChain published "Building a Harness with Jev" with official integration
• Vercel AI Gateway, OpenRouter, Netlify, Cloudflare Workers AI, and AIMLAPI all listed the model
• The Register, Gigazine, and numerous engineering blogs covered it — including hands-on benchmarks replacing LLM-based model routing
• Third-party playgrounds and guides sprang up independently

And the demo that traveled the furthest: Jev playing DOOM in real time at ~10 decisions per second, about $7 per hour of gameplay. Hacker News skeptics pointed out the demo reads a preprocessed text dump of the full game state rather than pixels, with little pathfinding — worth knowing before marveling — but the underlying point stands: decisions at 100ms latency let AI live inside real-time loops that chat models physically cannot.

The claims, framed fairly

The launch quantified it as "20–200x faster, 40–400x cheaper" than frontier LLMs on decision-shaped queries. The homepage's headline "193.6x faster, 444.6x cheaper" comes from their own workflow evaluations, and TypeSafe says explicitly that these sit at the high end of real-world gains — treat them as a ceiling, not an expectation. No independent reproduction of those headline figures exists yet; vendor and early-user benchmarks report large gains, but they aren't apples-to-apples. Requests carry a 32k-token working context (64k total), with 250k tokens/sec and 1,200 requests/min rate limits.

To their credit, TypeSafe publishes a "jaggedness" page for each model version that documents exactly what it does badly — numeric precision and counting, dates and times, literal reading, double negatives, and tasks that need extra levels of indirection. A lab that lists its own failure modes in public docs is a lab worth taking seriously.

Where it fits in your stack

The realistic use cases are the decisions you're currently paying chat-model prices for:

• Intent routing — classify an incoming message, then route to a database lookup, an LLM with the right context, or a human. Most of those paths never need a generative model at all
• Model routing — score how much reasoning a task needs and pick the cheap or expensive model accordingly (see the routing pattern)
• Tool gating — before an agent executes a shell command, judge whether it's read-only, reversible, or destructive
• Agent routing and context management — pick the right skill or subagent before the main model runs, and score which tool results are worth keeping
• Browser and computer use — choose the next action from a page's live action space, one fast step at a time
• Real-time creative and games — drive characters, avatars, or in-game moves at ~100ms per decision
• Data and spreadsheet judgment — score or rank rows on intent as you type, across thousands of items per run
• Content triage at scale — sort feeds, inboxes, notifications, or posts into read, skim, or skip
• Filtering and labeling at scale — score, sort, and classify documents, tickets, or events where "10,000 tiny decisions" was previously too expensive to even consider

The threshold pattern is the important one: act automatically above high confidence, ask for review in the middle ranges, and escalate to a person when confidence is low. Where those boundaries sit is your decision, in code you own — which is exactly where the risk tolerance should live.

Most of these are community demos built within a week of launch rather than benchmarked products, so treat them as a map of what fits, not a track record.

We ran it ourselves

If you want to skip to the practical material, our Jev guide covers the SDK, the primitive semantics, and the question-writing rules in full.

We put Jev to work on real workloads the moment we got access, and the experience matched the pitch better than most launches do.

The best test: ranking the same corpus of past work sessions two ways — first with a keyword baseline in SQL, then with Jev judging semantically. The rankings diverged, which is the whole point. Keyword counts matched strings; Jev matched meaning. The expensive-looking part — building labeled digests — happened once, in code, before the call.

The fan-out claim held up in practice too: all your questions in one call, evaluated in parallel against the same state. We sent a batch of per-item judgments in a single request and couldn't detect added latency from extra questions in the same call. At ~100ms per call and priced near zero, it's the first AI model we've used where it's genuinely cheaper to ask every question you might need than to design the asking carefully. The API is a few days old and the surrounding ecosystem is still settling into shape, so expect minor setup rough edges, but nothing structural.

One design principle worth highlighting: treat a returned choice as advisory — never auto-execute it without your own checks. That's the right psychology for a probability engine, not a limitation.

Is it worth trying?

If your product makes repeated, bounded judgments — routing, filtering, verification, classification — Jev is the cheapest and fastest way to make those decisions smart, full stop. If you need writing, reasoning, or anything open-ended, keep your LLM and let Jev decide which calls actually need it.

Start small: pick one decision in your workflow that's currently an LLM call or a brittle regex, and test Jev against a set of labeled examples. The direction of travel is clear either way — models that specialize in decisions rather than text are a genuinely new slot in the stack, and for the first time, one exists.

Note: Jev is available today through Vercel AI Gateway, OpenRouter, Netlify, Cloudflare Workers AI, and AIMLAPI. Watch out for unofficial sites like jevapi.org and jevai.org that resell API keys — the authoritative docs live at docs.typesafe.ai. Full setup, prompting rules, and integration patterns are in our Jev tool guide.