You're Using Jev Wrong: 5 Mistakes to Fix

Jev is a classifier, not a chatbot — and that single misunderstanding is why most people waste it. Jev takes a fuzzy question and hands back probabilities instead of a sentence, which is exactly why it runs about 200x faster and 400x cheaper than the best models OpenAI or Anthropic ship. I've been wiring it into my own workflows for weeks, and the same five mistakes keep showing up. Here's each one — and the fix.

What Is Jev and How Does It Actually Work?

Jev is an AI model that answers questions with probabilities, not prose. You can't chat with it. You hand it a decision, and it gives you a confidence score back.

Say a customer writes in: "I canceled my subscription last month but you charged me again." You need an AI system to route that to the right team — billing, technical, or sales. A large language model like Opus can read it and reply, "This is a billing issue, route it to billing." That works. But Jev can ingest the exact same question and tell you with a 92% confidence score that it goes to billing — and it does that roughly 200 times faster and 400 times cheaper.

How cheap is cheap? About $43 per billion tokens. At that price, running a normal LLM — even a small one like Haiku or Luna — for high-volume, repeatable decisions makes no sense.

The question to ask of your own stack is simple: is there a place where I'm making small, repeatable judgment calls? If yes, that's where Jev belongs. You can get access two ways right now — an API from Typesafe (typesafe.ai, which may still have a waitlist) or through OpenRouter.

Mistake 1: Treating Jev as a One-Time Setup Instead of a Self-Improving Loop

The first mistake is dropping Jev into a workflow once and calling it done. That's fine on day one. It falls apart by day 20.

Jev always returns probabilities — but are they the right probabilities? That depends entirely on the rule set you give it. And the rule set you write on day one is almost never your best version.

Here's a real example. I get hundreds of emails a day and want them sorted — sponsor pitches, agency inquiries, personal, junk. I could point Opus at my whole inbox every morning, but that's expensive. Instead I let Jev classify, fast and nearly free, with one guardrail: it can only drop an email in a bucket if it's at least 90% sure. Anything below that gets handed to Opus.

On day one, Jev confidently classified only 43% of my emails. By day 10, it hit 81% — a huge chunk of work shifted off Opus and onto the cheap model. That jump came from a self-improving loop.

How the self-improving loop works

Every Jev call gets three things:

• The email — the raw input to classify.
• The question — which pile does this go in? Brand deal, agency pitch, service pitch, personal, automated, or none of these.
• The rule book — definitions of what each bucket actually means.

The trick: every time Jev wasn't 90% sure and punted to Opus, I had Opus review Jev's rule book and propose an edit so the next round is sharper. The rule book is the thing that improves. Probabilities are just numbers — without logic behind them that fits your situation, they're meaningless.

Two things that make this reliable:

• Always offer a "none of these" option when you can. It gives Jev an out when nothing fits, so you don't get randomly inflated probabilities from a model with nowhere to put something.
• Use shadow mode to bootstrap. Instead of letting Jev sort for 10 days, let it watch Opus sort for 10 days. Opus then writes Jev's rule book from how it actually operated, and Jev takes over. If you tell Opus you want to implement Jev, it'll usually suggest this right away.

Mistake 2: Implementing Jev the Wrong Way in Browser Automations

Jev is about split-second decisions — and controlling a browser is nothing but a long series of decisions. (People have even wired Jev up to play Doom, which is the same idea: a game is just decisions, fast.) If you've done browser automation with Claude or Codex, you know it's powerful but can be painfully slow. Jev can make it dramatically faster and cheaper — if you pick the right implementation.

There are three strategies, and the mistake is assuming one always wins:

• Opus does everything — the standard agent loop inside the Claude Code app.
• Opus plans once, Jev executes — Opus writes steps 0 through 100 up front and hands the whole plan to Jev.
• Opus and Jev loop — every time a decision or click is needed, Opus makes a mini-plan, Jev executes, repeat.

On a messy task — searching Google Flights — the looping strategy was fastest and the only one that finished, taking 12 turns versus the standard 36, at less than half the cost (19 cents vs 53 cents). The "Opus plans everything up front, Jev runs it" approach got stuck and never completed.

But flip to a simple task — open a to-do app, create three tasks, check them off — and the ranking changes. There, "Opus plans once, Jev runs it" was by far the quickest, even though it failed on the complex job. The full loop was roughly tied with Opus-does-everything.

The answer depends on the task. Simple and repeatable? Let Opus plan once and let Jev go nuts. Messy and unpredictable — which is the usual case for browser control? Use the tight Opus-plans / Jev-executes loop. At scale, 36 turns versus 12 and 53 cents versus 19 add up fast.

Mistake 3: Not Using Jev for Compaction and Token Management

Compaction is what happens when you run /compact because your context window is filling up — 400K, 500K, 600K tokens. You don't want to keep operating in a bloated window, because it's more expensive and, across every model, the AI just gets worse.

Normally /compact ships your whole conversation back to Anthropic's servers to summarize, then resets the window. What if Jev handled that instead?

On a 600,000-token conversation, a normal /compact took 35 seconds. The Jev version took half a second — and it was cheaper, because the full conversation never left for Anthropic's servers to summarize.

The mechanism is different from a summary. Instead of compressing everything into a recap, Jev walks the conversation line by line and asks, "Is this relevant — yes or no?" It keeps the relevant parts and drops the rest. Nothing is truly lost — dropped content gets saved to disk the way Claude normally does, so you can pull it back if needed.

Is keeping exact text as good as a summary? I ran quizzes and tests against normal compaction, and accuracy came out just as good — but far faster. The only downside is a slightly heavier start: the next conversation opened at 26,000 tokens versus 16,000 after a normal compact, about 10K extra, which is negligible in practice.

I do this with a skill I built called Jev Compaction Plus — a fork of the fast Jev compaction with a few changes. Setup and usage instructions live in the repo.

Mistake 4: You Haven't Audited Your System to See Where Jev Fits

This is arguably the most important mistake, because the first three might not even apply to you. But I'll guarantee one thing: somewhere in your current stack is a workflow that could 100% use Jev. You just haven't looked.

Don't try to find it by hand — use AI to do it. I built an audit prompt you run inside Claude. It reads all your skills, hooks, scripts, and automations and finds every place you're currently using a heavier model to make small, repeatable decisions where Jev would make more sense.

For me it surfaced things like sorting emails and filtering AI news. For each one, it tells you which decision Jev would make, how that decision is made today, and how often it would actually run. Once you pick one, you go deeper — defining the choices and the confidence threshold a call has to clear before it executes. It's the fastest way to stop guessing and start finding real fits.

Mistake 5: You Have an AIOS but Aren't Using Jev Inside It

If you run an AI operating system — a stack that routes your requests to different models — you probably aren't using Jev for the routing. You should be.

Here's the problem it solves. When I give my AIOS a command by voice, it picks a model based on the task. Not everything needs Fable, Opus, or Astra. "What was in my emails today?" or "summarize the latest AI news" doesn't need a heavy model. Something had to make that call — and before, that classifier was a small model like Luna or Haiku. Cheap, but slow: routing sometimes took up to 5 seconds.

When I swapped in Jev for the routing, classification dropped to about a tenth of a second — cutting a 5-second round trip down to roughly 3 seconds end to end. My routing rules were clear, split into three tiers:

• Tier 1 — a basic Obsidian task, like pulling up the terminal inside Obsidian.
• Tier 2 — a task like "summarize today's AI news."
• Tier 3 — heavier work, like creating a project or a deliverable that doesn't exist yet and needs real power.

This is the core lesson about Jev: it's not the executor. Jev pushes work to Claude or OpenAI, which do the actual execution. But the decision about what to execute and who should execute it is exactly the kind of small, repeatable judgment call you can offload to Jev — in an AIOS or any workflow.

The Real Fix: Understand What Jev Is

Every one of these mistakes comes from the same root — misunderstanding what Jev does. Once it clicks that Jev takes fuzzy questions and returns probabilities, and nothing more, where it belongs becomes obvious: anywhere you're making small, repeatable decisions, fast and cheap.

And because it's basically free — $42 per billion tokens — the cost of testing it at scale is near zero. Even if you end up not using it for a given job, you won't have burned anything finding out. Lean on that audit prompt, find your first fit, and build the self-improving loop from there.

Frequently Asked Questions

What is Jev?

Jev is an AI model that returns probabilities instead of sentences. You hand it a question and it gives back a confidence score for each possible answer, which makes it a classifier rather than a chatbot. That design is why it runs roughly 200x faster and 400x cheaper than full large language models.

How much does Jev cost?

Around $43 per billion tokens — Chase cites both $42 and $43 in the video. At that price it's effectively free for high-volume classification compared to running even a small LLM like Haiku or Luna on the same decisions.

Where can I get access to Jev?

Two places: an API from Typesafe at typesafe.ai (which may still have a waitlist) or through OpenRouter. Both give you the same access to the model.

When should I use Jev instead of a large language model?

Use Jev anywhere you're making small, repeatable judgment calls — classification, routing, sorting, or fast decisions inside a loop. Keep the large language model for actual execution and for anything requiring reasoning or generated output, since Jev only returns probabilities and never executes the task itself.

How do I make Jev's answers more accurate over time?

Give it a rule book, and build a self-improving loop: whenever Jev isn't confident enough and hands a case to a model like Opus, have that model propose an edit to the rule book. In one inbox test this took confident classifications from 43% on day one to 81% by day ten.

---

If you want to go deeper into building with Jev and fast AI models, join the free Chase AI community for templates, prompts, and live breakdowns. And if you're serious about building with AI, check out the paid community, Chase AI+, for hands-on guidance on how to make money with AI.