Jev Is Here: How to Use It for Fast AI Decisions

What if you could sort 1,700 emails, score their importance, figure out which ones deserve a reply, and spend 18 cents on the entire job?

That is the demo that made Jev click for me. Not another chatbot. Not another tool that writes a paragraph explaining what you should do. A classifier that takes information, evaluates a set of choices, and returns structured results fast enough to put directly into a workflow.

Ryan Vogel, who is on the founding team of OpenCode, walked me through what he has been building with it. The speed is exciting. The cost is exciting. But the business opportunity is what really gets my brain going: find an expensive queue of incoming information and put Jev at the front of it.

Table of Contents

• What Is Jev? Start With a Classifier, Not a Chatbot
• The Email Demo: 1,700 Messages for 18 Cents
• A Decision Model Is Not a Replacement for Every LLM
• Use Jev as an AI Traffic Cop for Your Business
• The Startup Opportunity: Put Jev at the Front of an Expensive Queue
• Where Jev Struggles: The Bitcoin Test
• Two More Use Cases: Video Clipping and Browser Control
• How to Get Started With Jev

What Is Jev? Start With a Classifier, Not a Chatbot

The simplest mental model is this: an input and an output schema go in, and scores for the available choices come out.

A schema is just a definition of how the output should be organized. It specifies the fields you want back and the options or types those fields can contain. You do not need to think about a database to understand it.

Imagine giving Jev a text description of a phone and defining a color field with choices such as orange, red, blue, green, and yellow. Instead of composing an explanation about the phone, it evaluates those choices. An illustrative result might give orange an 80% probability, red 10%, and blue 10%.

The distinction matters. This is not simply a machine declaring, with absolute certainty, that the phone is orange. It is producing a probability-based assessment within the choices you supplied.

Now replace the phone description with an email, a sales inquiry, or a support request. Replace the colors with categories, priorities, or possible destinations. That is where this becomes useful.

You Define the Choices, Rather Than Asking for an Essay

With a conversational model, you might ask it to read an email and explain what you should do. With Jev, you supply the email and define the results you need, such as:

• Category: marketing, finance, work, security, or shopping.
• Priority: low, medium, high, important, or urgent.
• Spam score: a numeric assessment.
• Reply score: how strongly the message warrants a response.

Jev does not need to invent the category names. You have already supplied them. It does not return a conversational explanation or visible reasoning. It returns the structured output.

That is why developers get excited about the type-safe aspect. A numeric field comes back as a number, and a category comes back in the expected structure. The application can use those results directly rather than extracting them from a paragraph.

The useful distinction is not that other AI tools cannot produce structured data. It is that classification and structured decisions are the central job here, rather than an extra instruction attached to a conversation.

The Email Demo: 1,700 Messages for 18 Cents

Email is a perfect example because the problem is familiar. There is too much incoming information, not all of it matters, and the important stuff can disappear into the pile.

Ryan passed complete email objects into Jev: subject, description, body, sender, and the other email fields. He did not describe a complicated preprocessing ritual. The email itself was the input.

Each message received the four assessments above: category, priority, spam score, and reply score.

Those fields answer different questions. A promotional email from an old Kickstarter signup might be unwanted and score as spammy. A payment notification could be useful information without requiring a response. A customer reporting a possible account violation could deserve immediate attention.

That last distinction is easy to miss. “Not spam” does not mean “needs my attention right now.” You need more than one label to build a genuinely useful inbox.

Ryan ran the classification across about 1,700 emails. The reported usage was 4.2 million input tokens and 500,000 output tokens, with a total cost of $0.18 for the whole run, not 18 cents per email.

The batch finished during the demo rather than turning into the long, expensive processing job he jokingly pretended to dread.

That result is a demonstration, not a universal price quote. Your workload will be different. But it makes the opportunity tangible: once classification becomes cheap enough, you can reconsider jobs you previously would not have bothered automating.

A Decision Model Is Not a Replacement for Every LLM

I initially described Jev as an AI decision maker. Ryan refined that: it produces a probability-based assessment of a decision. Your application still determines what to do with the result.

For example, a system might receive a stronger score for “buy” than “do not buy.” That does not make the underlying assessment certain. Similarly, a high spam score can inform a routing rule without proving that a message is spam.

Thinking of Jev as a chat assistant leads you in the wrong direction. It is not designed for an open-ended exchange about how your day is going. It is built to evaluate defined outputs.

The Letter-by-Letter Experiment Makes the Difference Clear

Ryan tried a wonderfully nerdy experiment: could he turn classification into text generation?

His reasoning was that typing is a sequence of decisions. To write “hello,” you choose H, then E, then L, then L, then O. What if the available outputs were letters, and Jev repeatedly selected the next one based on the preceding letters?

He tested that setup with a simple question about whether a cat or an elephant is bigger. The experiment ran quickly, but it did not behave like a capable conversational model.

That is the point. You can bend a classifier toward another task, but that does not make it the right tool for the task. Use Jev where selecting, scoring, and routing are the product. Keep generative models for the parts that actually need generation.

Use Jev as an AI Traffic Cop for Your Business

The metaphor that works best for me is an AI traffic cop.

Information arrives. Jev helps determine what it is, how important it is, and where it should go next. The destination could be a person, an automated workflow, or another AI model.

Ryan described queries taking around 200 milliseconds in his experience. Treat that as a reported performance characteristic, not a guaranteed response time for every deployment. Even so, it points to a different experience from waiting for a conversational response to stream and finish before the next step can run.

Lead Scoring for a Graphic Design Agency

Ryan’s girlfriend runs a graphic design agency and receives inquiries through a website contact form. Some are promising leads. Others are solicitations or vague requests that need much more qualification.

She uses Jev to score whether an inquiry looks like a good lead, on a scale from zero to one.

A strong inquiry can rise to the top for a fast personal response. A less developed inquiry might need follow-up questions. An obvious solicitation can be deprioritized.

The practical value is not merely attaching a score. It is allocating the owner’s time. A high-value prospect should not sit behind a pile of irrelevant messages.

You can apply the same idea to historical email. Instead of only organizing new messages, scan the backlog for promising inquiries you missed or previous clients worth reconnecting with.

Support Triage and Team Routing

Support creates another expensive queue. A request arrives about a particular product, and somebody has to work out which team owns it.

A classifier can assess the request against defined product teams and help route it immediately. Priority can be a separate field, so routing and urgency do not get collapsed into one decision.

The broader workflow might look like this:

• Strong, high-value signal: send it to a person who should act quickly.
• Routine inquiry: send it into automation or use an LLM to draft the next response.
• Low-value or unwanted message: deprioritize it according to the business’s rules.

Keep Jev in a heavily advisory role, especially while testing. A score helps you make a decision. It is not permission to automate every interaction without checking the consequences.

The Startup Opportunity: Put Jev at the Front of an Expensive Queue

Here is the question I would ask as a founder:

Where does a business pay people to read incoming information, make a repeatable judgment, and send it somewhere else?

That is a much more useful starting point than asking what generic AI app you could build.

You are looking for a queue where slow sorting creates a real cost: delayed responses, missed opportunities, or people spending their day forwarding requests instead of doing valuable work.

Local Services Matching

Ryan suggested a services aggregation business. Someone submits a request such as needing a driveway power washed. The platform has information about nearby providers.

Jev could evaluate the request alongside that provider information and score which businesses appear to be the best fit. The customer gets a match quickly instead of waiting for somebody to read the form and forward it manually.

There is still architecture around this. You need provider information, the matching workflow, and the application that turns a result into something useful. The classifier is a component, not the entire marketplace.

Make “Instant Quote” Forms Feel Instant

We have all encountered forms that promise an instant quote and then announce that somebody will email later.

A fast classification layer could help determine whether a job fits a provider’s services and move the customer into the right quoting path immediately. Where the rest of the pricing system supports it, that could contribute to a genuinely instant quote.

Jev does not magically supply pricing logic. But it can remove a slow initial judgment from the process.

That speed communicates something valuable: we respect your time, and we are not going to make you wait just to learn whether we can help.

Where Jev Struggles: The Bitcoin Test

Not every decision-shaped problem is a good classifier application.

Ryan connected Jev to a Bitcoin signal experiment that evaluated buy, hold, or sell every minute. His assessment was straightforward: it was not doing well, and he would not put it in charge of a portfolio.

He also tested a frontier model, which did somewhat better while cross-referencing news. But that was not an apples-to-apples comparison. A model using additional information and broader capabilities is doing a different job.

The lesson is important: a fast answer is not automatically a good answer. Sorting a support request and anticipating a market move may both end in a choice, but they demand very different capabilities.

Use Jev for the routing-style work it handles well. Do not mistake low cost and low latency for universal intelligence.

Two More Use Cases: Video Clipping and Browser Control

Finding Strong Moments in Long Videos

Ryan built a rough video-clipping prototype in about 10 minutes.

The workflow started with a video file. Another part of the system converted its audio into word-level text, and that text was passed to Jev with classification criteria for identifying promising clips.

The demo scored 17 candidate moments in roughly three seconds. The goal was to surface substantive moments rather than filler or setup chatter.

This is a useful distinction: Jev was not independently handling every part of video production. It was the scoring layer inside a larger workflow.

A more developed product could combine that fast selection step with other agents or tools. The prototype showed a starting point, not a finished clipping business or a guarantee that every suggested moment would perform well.

Choosing a Flight in 7.1 Seconds

Ryan also shared a Browser Use demonstration in which Jev helped control a browser to find a flight from Zurich to London. The demonstrated task completed in 7.1 seconds.

The interesting idea is that browser interaction contains repeated decisions: which field to select, which date to choose, and which action to take next. A fast decision layer can make those interactions feel much more responsive.

That single demonstration does not establish performance across all websites. It does show why latency matters beyond back-office sorting. When decisions happen inside an interactive product, speed becomes part of the product experience.

How to Get Started With Jev

At the time of our conversation, direct access through Typesafe AI was waitlisted. Ryan pointed to Vercel AI Gateway as an available route for experimenting without waiting for direct access. Availability can change, so check the current options before building around either route.

You do not need a giant experiment budget to start. Ryan said his team used a $5 introductory credit for two days of heavy experimentation without exhausting it. His broader cost estimates were informal, not a pricing commitment, but the barrier to trying a small workload was clearly low.

A practical first experiment looks like this:

1. Choose one recurring queue. Start with contact-form inquiries, support requests, or an email backlog.
2. Define the judgments you already make. Category, urgency, lead quality, and routing destination are useful starting points.
3. Specify the output schema. Decide which fields are scores and which have a fixed set of choices.
4. Compare the results with your own judgment. Keep the first version advisory rather than immediately handing it control.
5. Connect useful results to the next step. That might be a human notification, an automated workflow, or a generative model.

Ryan’s other suggestion is simple: give your coding agent the relevant documentation and explain your business. Ask which daily workflows could benefit from a fast classifier, then have it help you build a small test.

The big shift is not “replace every LLM with Jev.” It is stop using a conversation when what you need is a structured judgment. Find the pile of information someone has to sort every day. That is where I would start.