This video introduces TypeSafe's Jev as a general-purpose classifier that, instead of generating sentences, reads complex information and picks one of a set of predefined options. Rather than replacing existing LLMs, Jev is a tool for handling the judgment tasks LLMs have been doing—such as email triage and agent safety checks—faster and more cheaply. The key point is that once classification gets cheap, judgments that were previously abandoned can be applied throughout software.

1. Why Did an AI That Doesn't Write Get So Much Attention?

Jev reads complex text as input, but it does not write its answer as prose. The user provides the possible answers in advance, and Jev picks one of them. The host likens it to "an LLM that can only answer multiple-choice questions." At first glance this might seem useless in an era overflowing with models that write well, but the host explains that within 24 hours of TypeSafe's launch, Jev became the fastest-adopted model in the history of the Vercel AI Gateway. Its number of paying-team adoptions in the first 24 hours was also more than double that of any previously launched model.

"Unless a lot of brilliant developers lost their judgment all at once, the fact that Jev 'doesn't write' may be exactly the point."

The host previews four topics for the video: how to recognize which tasks suit Jev, how it is used in real systems, what it costs to try, and the areas Jev does not handle well. In particular, the host emphasizes that this is not a claim that Jev replaces LLMs. Rather, the explanation is that adding a non-LLM, selection-based model makes the division of roles within AI systems clearer.

2. The Gap Between Rules and LLMs

Software has long handled clear-cut conditions. For example, flagging an invoice that is more than 30 days overdue, or warning when an order total exceeds a limit, can be handled with ordinary code by writing the condition precisely. But judging from a customer email "Are they likely to cancel their contract?" or "Is this a real business opportunity, or does it just contain the phrase 'business opportunity'?" is hard to handle with fixed rules alone.

Problems like these require understanding complex text, but the result is simple: choosing a category, assigning a score, or deciding "yes/no" on whether to proceed. The host calls such tasks classification problems—more specifically, semi-deterministic problems that connect text to a choice. The judgment itself may be probabilistic, but by restricting the output to predefined options, downstream software can handle it consistently.

"What we're doing is reading complex text and making an action or a simple choice."

Traditional machine-learning classifiers required collecting examples, having humans label data, training and evaluating a model, and then maintaining it as the problem changed. Once built well, they were cheap to run, but each new classification task required data, expertise, and evaluation work. So while useful for large platforms, they were burdensome to apply to the countless small judgment tasks scattered across digital products.

LLMs began filling this gap. Without separate training, from a description alone, they could classify messages, choose tools, judge the relevance of documents, or check other models' outputs. However, because a text-generation model is being used for a simple selection task, it can cost more than necessary. This is where Jev comes in: a general-purpose classifier designed to interpret complex information but return only predefined options.

3. Four Roles Jev Can Play

The host likens Jev to a new Lego block that can be slotted into existing software. If code handles calculation and data lookup, and LLMs handle reasoning, planning, and text generation, then Jev reads a complex situation and picks one of a fixed set of outcomes. The host explains that Jev can evaluate multiple questions at once and does not require training a new model every time the classification task changes.

The first use is classifying information between complex inputs and existing workflows. If Jev reads a customer support ticket and determines whether it is a billing inquiry, whether it needs a reply today, and whether the customer is at risk of churning, the software can assign the responsible team and the priority. It could also find marketing opportunities in emails, judge whether they are worth replying to and how large the opportunity is, and then have an LLM draft a reply only when needed.

"Jev can decide whether something is worth your attention, and a model can handle actually writing the email."

The second is narrowing down the important items in a large problem space. A developer who applied Jev to tax-document processing reported that, compared with their previous LLM approach, it cost 1/34 as much and was 6 times faster. One entrepreneur was described as spending 7 minutes and $1 to find complaints, upsell opportunities, and missed follow-ups across some 20,000 emails, Slack messages, and conversation logs. In an immunology research example, Jev was used to select the 100 most important questions from 10,000 literature-based candidate questions. This doesn't mean Jev solves the research questions themselves; it means it quickly narrows down what humans should pay attention to.

The third is deciding the next step of an AI agent or workflow. When an agent tries to delete a build folder or force-push code, Jev can judge the risk and have the agent ask the user for confirmation. In larger workflows, Jev can look at the current state of a document and choose whether to use an ordinary tool next, hand text generation to an LLM, call a more powerful reasoning model, or pass it to a human. In browser automation, it can also take on the role of choosing the next action among the limited buttons and links on the screen.

The fourth is making software respond in real time to what the user intends. The video shows an example where typing "Urgency" as a spreadsheet column header lets Jev recognize its meaning and classify whether each row is urgent. Other columns can judge missing information or the responsible team, and ordinary formulas can combine those judgments with date and amount calculations. If needed, an LLM can be connected at the end to write responses.

"Spreadsheets show how calculation and linguistic judgment can naturally work together."

4. Not a Perfect Tool—Validate It on Real Problems

The host does not claim that Jev is the perfect tool for every task. It can still make mistakes, so you need to test it directly on your own classification problems. What you compare it against may be not only the LLM you currently use, but also existing machine-learning classifiers or human judgment. The cost is likely to be lower than an LLM in most cases, but the explanation is that you should verify the actual accuracy and results before adopting it.

To find tasks that fit Jev, look for "places where complex information comes in and a simple choice comes out." Examples include understanding the content of an email to pick the responsible department, or reviewing an agent's action to decide among allow, block, or ask a human for confirmation.

Getting started is also described as not difficult. You can feed TypeSafe's agent setup instructions to a coding agent such as Claude Code or Codex, connect your account and API key, and have it look for suitable classification tasks in your current project. The host says they built their own email-triage tool this way. You can also ask the agent to switch an existing LLM selection task over to Jev and compare speed, cost, and results.

"Find the inefficient spots in your project where an LLM picks one of a fixed set of outcomes, build a Jev version, and compare the results, speed, and cost."

5. What Low Cost and High Speed Change

The price cited in the video is 4.2 cents per million input tokens, with no output cost. If each request uses 1,000 input tokens, 1,000 calls cost about 4 cents and 10,000 calls about 42 cents. Under the same conditions, 1 million requests come to about $42. TypeSafe's launch evaluation claimed speeds close to 100 times faster than LLMs and costs that could be more than 100 times lower, and the host adds that they used it themselves and also looked at other developers' cases.

These cost savings don't just reduce existing AI spending. They expand the very range of tasks where judgment is worth applying. Judgments that were abandoned because they were too expensive can now be run more often and in finer detail. For example, a company that only reviewed a sample of customer calls could check every call against multiple criteria, or documents classified once could be reclassified daily based on customer reactions. Safety checks that were only done at the start of an agent's task could expand to checks at every step.

This shift connects to the Jevons paradox: the idea that as efficiency rises and the cost of using a resource falls, total usage can actually increase. The host explains that Jev's name also comes from this idea. When intelligence becomes cheap to use, it doesn't just make tasks you were already paying for cheaper—it creates new tasks that were never attempted because of cost.

"Once the cost gets low enough, you can ask questions you previously decided weren't worth paying for."

6. The Role of LLMs May Grow Rather Than Disappear

If Jev takes on more classification, it might seem that LLMs will have less work, but the host thinks the total amount of useful AI work may actually increase. When cheap classification uncovers new opportunities and filters out harder exceptions, those problems get passed to LLMs or humans capable of reasoning, explaining, and writing. In other words, Jev handles simple choices, and LLMs can focus on situations that truly require reasoning or writing.

Toward the end of the video, the host sums up that developers have so far handled these tasks with rules, built dedicated classifiers only when the cost was justified, or pressed LLMs into selection tasks. Jev is a new software component sitting between these, and the host also emphasizes that it is offered in a form that more people—not just engineers—can use through coding agents.

The host suggests viewers look at the software they use every day from Jev's perspective: find whether judgments that interpret complex information and pick one of a few outcomes are already buried inside expensive AI calls, or whether there are judgments that have been skipped entirely until now because of cost and complexity.

"What if every element responded intelligently? What if every row understood the user's intent, and every document were evaluated against the criteria that matter right now?"

Finally, the host offers encouragement to small teams and solo developers. Ideas nobody in the industry expected can create big changes, and the host reminds viewers that Jev was also built by a small team. The video closes by urging those who haven't tried Jev yet to apply it to problems where the input is complex and the output narrows to a few options, and to test what possibilities it opens up in their own work.