🛠️ 100x Cheaper Than Claude? JEV is One of the Ridiculously Cheapest AI Right Now

Introduction

Jev can’t write a sentence. And that may be exactly why you should pay attention.

Most LLMs are trained to generate text for humans. But Jev takes a very different approach.

It is built to return structured decisions your code can act on, such as a classification, a score, or a true/false judgment with confidence attached.

Companies like Vercel are already testing it in production, and the early results are hard to ignore.

If you’re looking for the cheapest LLM API for routing, classification, verification, or agent workflows, Jev is one of the most interesting models to watch.

I. What Jev Is and Why It’s Different

Jev is the first product from TypeSafe AI, a San Francisco lab that came out of stealth on September 15, with a $40 million seed round led by DCVC.

Who built it: CEO Diogo Almeida co-authored OpenAI's 2022 InstructGPT paper, the research that helped turn GPT-3 into a useful instruction-following system, and contributed to the original ChatGPT release.

He spent 2 years in stealth building TypeSafe with co-founders Erik Gafni and Sasha Sheng (COO, a former Meta and FAIR research engineer).

1. The Core Idea: System 1 vs. System 2

TypeSafe borrowed a concept from Daniel Kahneman's Thinking, Fast and Slow to explain what Jev does:

Most LLMs now behave like System 2. They generate a response one token at a time, building each piece from what came before. That process takes time, burns tokens, and produces more output than your code usually needs.

Jev is built around System 1: make a fast judgment from available information and return that decision directly.

2. How It Works Under the Hood

Jev uses three things TypeSafe built from scratch:

• A new model architecture, not published in detail yet

• A parallel sampler, so it can evaluate multiple questions at once against the same input

• RLCD (Reinforcement Learning for Calibrated Decisions), where "calibrated" has a specific meaning: if Jev says it's 70% confident, it should be right about 70% of the time.

You send Jev a state, which can be text, JSON, or any structured data your app already has, plus a set of typed questions.

Jev evaluates all questions in parallel and returns structured JSON your code can use immediately.

II. The Three Question Types

Jev works with three kinds of questions.

Choice picks one option from a set you define:

"Which team should handle this ticket?" → billing, technical, or sales

Score rates something on an ordered scale:

"How frustrated is this customer?" → 0.82 (on a 0 to 1 scale)

Boolean answers a yes/no question with a confidence value:

"Does this message mention a deadline?" → 0.94

That's the full API surface. Jev reportedly supports up to 255 choices in a single Choice question. It cannot generate open-ended text, write code, or produce anything that requires stringing words together.

Here’s a simple example:

→ That output can go straight into your routing logic, fraud checks, support workflow, or agent tool selection.

Or this, I think it’s a more useful test, itcompares Jev with a normal LLM on the exact same 27 questions.

The task includes decisions such as:

• revenue impact, churn risk, security risk, and account health

• which department should handle the issue, which resolution is needed, and how urgent the case is

Jev returns structured answers for all 27 questions at once, including scores, choices, probabilities, and confidence values.

In the test shown, Jev completed the request in about 0.114 seconds at a cost of roughly $0.000081.

The LLM version took about 8.566 seconds and cost around $0.01388 for the same set of questions.

→ That works out to roughly 74.9x faster and 171x cheaper in this specific test.

A More Useful Example: Support Ticket Triage

The clearest way to see the value is a support ticket.

TypeSafe's own documentation uses this example: a customer writes that they've been trying to connect their Stripe account for 3 days, it keeps failing, and they're losing sales. You send that message as the state, plus one Noul question asking whether the message conveys urgency. Jev returns 0.999 - a 99.9% probability that the ticket is urgent. No sentence, no parsing, just a number your routing logic can threshold on. (full request and response, via LangChain)

The bigger win comes from batching. Instead of one question, you send the whole set against the same state in a single call:

Each question is evaluated in parallel and in isolation against the same state, so adding questions barely changes latency. TypeSafe's parallel-questions cookbook reports that batching a 13-question set over one document came out roughly 12x cheaper and 10x faster than asking one question per call. (worked open-source example)

This is where the cheapest LLM API angle gets concrete. If your app makes thousands of these decisions a day, cost per decision and latency matter far more than how well the model writes.

III. The Speed and Cost, With Honest Context

1. What TypeSafe Reports

• End-to-end latency: 70 to 500ms (versus 3 to 329 seconds for frontier chat models on the same tasks)

• Performance gains: 20 to 200x faster and 40 to 400x cheaper at comparable intelligence on "System One" tasks

• Headline workflow figure: 193.6x faster and 444.6x cheaper (the peak on TypeSafe's own workflow evals, which Vercel's changelog also cites)

• Pricing: $0.042 per million input tokens, output free

In a published test comparing 27 simultaneous decisions, Jev completed the batch in about 0.114 seconds at a cost of roughly $0.000081.

The equivalent LLM run took about 8.566 seconds and cost around $0.01388, which works out to roughly 74.9x faster and 171x cheaper for that specific test.

2. The Honest Caveats

1. All evals are internal. TypeSafe's capabilities staff created the workflow evaluations, and the reference answers come from the averaged output of frontier models like GPT-6 Astra and Claude Fable 5.1. TypeSafe itself acknowledges this may introduce bias.

2. The 193.6x figure is the ceiling. TypeSafe says the largest numbers sit near the high end of gains customers should expect. Real-world gains will vary significantly depending on your specific task, state complexity, and how many questions you batch.

3. The Vercel result is one team's classifier benchmark. Jev is now available on the Vercel AI Gateway, and Vercel's fx team benchmarked it against their current safety classifier, which runs on GPT Luna. They report Jev is up to 18x faster at p95 and more accurate, and say it's likely to become their new default.

4. "Zero hallucinations" is a narrow promise. It means Jev's output will always match the schema you declared, with no invented fields, malformed values, or invalid types. It does not mean Jev always picks the right answer. It can and will make wrong classification calls.

IV. Where Jev Is Actually Useful

The strongest Jev use cases show up when your system has to make lots of small decisions, very quickly, and you do not need a full LLM response every time.

For developers, that can mean:

• Guardrails, model routing, and ticket triage

• Tool selection inside agents, including choosing between MCP tools, skills, or CLI actions

A normal agent might call another model, wait for a text response, interpret it, then continue.

Jev can handle that decision layer much faster. That can reduce both latency and cost across workflows with a lot of repeated decisions.

1. Vercel Tested Jev for Classification

One of the more interesting early examples comes from Vercel.

TypeSafe has shared that Jev reached 100% accuracy on a Vercel classification eval. That gives us a useful signal about performance on the task.

That matters because classification is one of the clearest places where a decision model can make sense. You usually do not need a long answer. You need a reliable label, score, or routing decision that your code can use immediately.

If you are comparing the cheapest LLM API for this kind of workload, raw token pricing is only part of the picture. A better question is:

For Jev, that is the metric worth watching as more public benchmarks and production examples appear.

OpenCode has also tested Jev in browser-use workflows and highlighted its speed, which adds another example of how low-latency decisions could help agent systems move faster.

2. The Demos Show How Far This Can Go

Some of the community experiments are more playful, but they show the same underlying pattern.

There was also a StarCraft experiment where Jev was used to make game decisions and complete missions.

The interesting part here is not the game itself. It is the number of fast decisions happening underneath.

In Doom, for example, the model keeps receiving a structured state and sending back structured actions. That means it can be called repeatedly without generating long blocks of text every time.

The same principle applies to real software.

→ A fraud system can score risk. A support system can route tickets. An agent can pick tools. A coding workflow can decide which model handles the next task.

Conclusion

Jev is built around one simple idea: your code often needs a decision, not a paragraph.

For classification, routing, scoring, guardrails, and tool selection, that can mean faster responses, lower costs, and fewer unnecessary tokens. That is why Jev is interesting for anyone comparing the cheapest LLM API options for high-volume AI workflows.

The question now is simple: Which decisions inside your system could be turned into a choice, score, or yes/no probability?

If the answer is “a lot,” Jev could save you far more than a few milliseconds.

If you are interested in other topics and how AI is transforming different aspects of our lives or even in making money using AI with more detailed, step-by-step guidance, you can find our other articles here:

• Fable 5.1 Watermarks EVERYTHING. Here’s The Trick to Easily Remove All of It

• GPT-6 Astra Gets 10X More Productivity When You Give It This One Type of Data

• Run GPT-6 Astra, Fable 5.1, Even Other Agents Simultaneously in This Free AI Workspace*

• GPT-6 Astra Kills AI Website Slop Forever Using Just One Prompting Method*

• GPT-6 Astra + Fable 5.1 Together= AI GOD MODE to Save You 20x More (90% Cost-Saving)*

  *indicates a premium content, if any