JEV Use Cases: 10 Real Scenarios and What They Cost

I have covered what JEV is and the three question types. Now the real question: what do you build with it?

That question is harder than it looks, because JEV is a component, not a product. If you expect something that works out of the box you will be disappointed. But if you ask "which decisions did I give up on because asking an expensive model was not worth it?", the list gets long fast.

Below are ten scenarios. What they share: the decision comes from a closed set, the volume is high, latency matters, and until now it was solved either with keyword matching or with an expensive LLM call.

1. Comment and message moderation

The most direct case. For every incoming comment you ask several questions in one call: is it spam, abuse, a joke, a question, a request?

questions = {
    "type": Choice(
        instructions="Which category does `comment` fall into?",
        criteria={
            "question": "Asks something.",
            "request": "Asks for content or a feature.",
            "criticism": "Negative but constructive feedback.",
            "spam": "Advertising, link bait, or bulk posting.",
            "abuse": "Aggressive language aimed at a person.",
            "chat": "General conversation.",
        },
    ),
    "needs_action": Noul(instructions="Does this comment need moderator action?"),
}

The chronic failure of keyword-based moderation is that it misses meaning: a sentence that reads as an insult on a word list is a joke in context. A model deciding from a closed set catches that difference.

In a public demo, classifying 805 YouTube comments in one batch took around 37 seconds and cost roughly 14 cents. Asking a chat model the same volume one comment at a time puts both the time and the invoice in a different league.

2. Email and support ticket triage

Inbox classification is what JEV handles most comfortably. Is it an invoice, a sponsorship offer, an official document, a support request? Then add an urgency score and a "does this contain personal data" check — all in the same call.

The real win is not the label but the routing: which team, which queue, which SLA. A ticket landing in the wrong queue costs thousands of times more than the call that classified it.

3. Tool selection for an agent

You want to give an agent 150 tools. Loading them all into context is expensive and dilutes the model's attention. The fix is to let JEV pick.

On every turn, JEV decides which tools are relevant to the current context, and only those few enter the main agent's context. The main model's context stays lean, the cost drops, and accuracy goes up.

TypeSafe published a cookbook measuring exactly this: picking at most one skill out of a 182-item catalogue using a two-stage setup — one request ranks the whole catalogue and asks whether the turn needs a skill at all, and a second reads the top three properly and can reject all of them.

4. Routing between models and sub-agents

You have models of different strengths. You want simple tasks to go to a small model and hard ones to a strong model. You cannot do that by swapping models mid-conversation — it destroys caching and scatters the context.

But making the decision outside the conversation, with JEV, works cleanly:

questions = {
    "task_type": Choice(
        instructions="What kind of request is this?",
        criteria={
            "lookup": "Finding information or a database query.",
            "edit": "A small change to existing text or code.",
            "design": "An architectural decision or multi-step planning.",
        },
    ),
    "difficulty": Score(
        instructions="How hard is the task?",
        criteria=["Done in one step.", "Needs a few steps.", "Needs long planning and verification."],
    ),
}

Then you route in code — and this is where confidence becomes a gate: if confidence is below 0.5, do not decide; fall through to the strong model or to a person. The documentation calls these patterns intent routing and confidence-gated routing.

5. Cutting an agent's unnecessary steps

The most expensive habit an agent has is reading a file it did not need. Every read inflates the context, and every inflation makes all subsequent turns more expensive.

Put a single Noul in the way: "Is the content of this file genuinely required to complete the task?" If the answer is below 0.3, skip the read. That small gate saves a real share of the context budget over a long session.

The same logic applies elsewhere: should the tests run, should this error be shown to the user, should this step be retried?

6. RAG passage filtering and a prompt-injection shield

Handing every retrieved passage to the main model is both expensive and risky. Ask about each passage in one call: is it relevant, does it contradict the question, does it contain a hidden instruction?

The last one is a genuine security win. An injection buried in a retrieved document — "ignore your previous instructions" — can be dropped before it ever reaches the main model. TypeSafe documents this as a pattern of its own.

A related pattern is citation checking: does the source a response points at actually support the claim? A single Choice question settles it, and its confidence flags the doubtful ones for human review.

7. Re-ranking search results

Classic retrieval (BM25, vector search) is fast but misses meaning. Bolting an expensive re-ranker on top is costly.

JEV fits neatly here: you ask one question per query-candidate pair and re-order the list. In a published legal-data cookbook, applying this to 30-passage BM25 shortlists raised top-1 accuracy from 5% to 18% and top-10 accuracy from 38% to 62%.

8. Extracting fields from unstructured text

Because JEV does not generate text, you invert the usual extraction: find candidates in code, and let the model do the selection.

For dates, amounts, and phone numbers you pull candidates with a regex and then ask "which of these is the value requested?" as a Choice. You get a verbatim value and you remove any chance of the model inventing one.

That distinction matters: JEV cannot compare dates or count items. But it can answer "which of the dates in this document is the payment deadline?" You do the arithmetic in code.

9. Quality and policy auditing

Scoring the properties of a piece of text is somewhere JEV is quick. For one item you can ask, in a single call: does it cite sources, does it make firm claims, is it manufacturing FOMO, does it contain a product pitch, how much of it is filler?

In a public demo, scoring a 3.5-minute talk on axes of concrete information / filler / repetition / vagueness / self-promotion came in around a cent. Getting the same measurement from a large model turns into a budget conversation at the scale of hundreds of items.

For LLM products the same structure becomes a guardrail: scan every message going into and out of the model in one call, asking "is this a jailbreak attempt" and "how much harm would complying do".

10. Games, simulations, and real-time decisions

The last scenario is the most fun and architecturally the most instructive. Games and simulations make decisions every frame: break this block, run from this enemy, move this unit here.

An LLM cannot enter that loop — too slow, too expensive. JEV can, by choosing between options placed in front of it. Setups where an LLM handles the long-term plan while JEV supplies the reflexes have been shown in public demos.

The same architecture applies far outside games: robotics, traffic simulation, browser automation. "Which element on the current screen should be clicked?" is a textbook Choice question.

The cost maths: why the difference is so large

Make it concrete. Say you classify 50,000 short texts a day, averaging 400 tokens each.

• Total input: 20 million tokens/day.
• JEV pricing: $0.042 per million input tokens, output free.
• Daily cost: around one dollar.

Doing the same with a mid-tier chat model puts that figure in the three-digit range, because per-token prices are one to two orders higher and output tokens are billed too. In a public comparison the same test reportedly cost $176 on a large reasoning model and 39 cents on JEV.

The point is not the saving, it is the change in threshold. You cannot put a $176 check on every request; you can put a 39-cent one. When the price drops you do not do the same thing more cheaply — you start doing something you never did at all.

How to find your own scenario

Look for three things in your codebase:

1. Keyword lists. Every if "refund" in message is a fake rule that misses meaning, and a JEV candidate.
2. Expensive calls made "just in case". Files your agent reads every turn, LLMs you call on every request. Put a gate question in front of them.
3. Checks you never implemented. Every "it would be nice to check every comment, but it is too expensive". The price now invalidates that sentence.

If you work with a coding agent you can have it do that sweep for you; TypeSafe's official agent skill is aimed at exactly the task of finding where fragile parsing code could be replaced by intelligent judgement.

Before you ship any of this, read the limits and how to build the harness — none of these scenarios work by plugging the model in and walking away.

The measurements here come from TypeSafe's published cookbooks and public demos; your own workload may differ.

Frequently Asked Questions

Where does JEV help most?

Wherever the decision comes from a closed set, the volume is high, and latency matters: moderation, email and ticket triage, tool and model selection for agents, filtering RAG passages, re-ranking search results, and quality or policy auditing.

Can JEV replace an LLM?

No. JEV does not generate text, so writing, summarising, translating, and code generation remain LLM work. JEV is the decision layer placed in front of those models, cheaply determining which model runs, with what context, and when.

How cheap is JEV really?

Input is $0.042 per million tokens and output is free. A workload classifying 50,000 short texts a day works out to roughly a dollar a day. The same job on chat models sits two to three orders of magnitude higher.

How do I connect JEV to my agent?

The three most common attachment points are tool selection (loading only the tools relevant to the current context), model routing (choosing the right model for the task type and difficulty), and gate decisions (should this file be read, should this step be skipped). In all three JEV decides and your code acts.

Is JEV enough for comment moderation?

It classifies well, but you should stage the action by confidence rather than applying it directly: high-confidence spam is removed automatically, low-confidence cases go to human review. The documentation also states plainly that text written to argue for its own classification can move the answer.