What is Jev (and why I started using it)

Hey everyone!

Everyone who has ever put an LLM into production knows this ritual:

1. Write a huge prompt.
2. Ask the model to “respond ONLY with JSON”.
3. Pray it doesn't invent a field.
4. Parse it, handle the error, and hope the result is the same next time.

It works, but it's like using a cannon to kill a mosquito. Most of the time I don't want the AI to write anything. I want it to decide just one little thing.

Jev is a model from TypeSafe built exactly for this. It doesn't generate text. You send it a context and a question with the possible answers, and it returns a typed answer with a probability.

A traditional LLM is that friend who talks too much. You ask, “is the recipe in the caption?” and it gives you back a whole paragraph.

Jev is that straight-to-the-point friend: “Yes, 97% confidence.” Done. Then it's your code that decides what to do with that.

The three types of questions

With Jev you only ask three types of questions:

• Noul (yes or no): “Does this caption have enough ingredients to build a shopping list?” → 0.97.
• Choice (pick one option): “Where's the recipe?” → comments, with 100% confidence.
• Score (a rating on a scale): “How urgent is this message?” → a position on the scale that you defined yourself.

To build a question you send three things:

1. The state, that is, the context: the caption, the message, whatever it is.
2. The instruction, which is the question itself.
3. The criteria, which say what each answer means.

Real example: claude_notify

In my Telegram bot that controls Claude Code, when it asks for permission to run a command, before I could only recognize y, yes or 1. If I replied “yes, go ahead,” the bot wouldn't understand and would type the entire text into the terminal.

Now Jev interprets the response:

• “yes, go ahead” → approve (1.0). The bot clicks Yes.
• “okay, but don't touch the migrations” → approve with instruction. The bot does NOT click the button, because it would lose the condition I added.
• “why does it need rm -rf?” → question. Sends the text to Claude.

And notice that I never configured Portuguese. It simply understood.

Real example: MiseSnag

In MiseSnag I used to decide with regex whether the video caption already had the recipe. If it does, I skip the download and the transcription, which is where the cost is. I tested 6 captions:

• The regex got 2 wrong. It didn't recognize a list of ingredients without quantities and thought that “Ingredients: see video!” was a recipe.
• Jev got all 6 right. And as a bonus, it even said where the recipe was: in the comments, on screen, or spoken.

Every regex mistake costs money: download, Whisper, a wasted LLM call.

What I like most

1. The code stays in control. Jev gives its opinion and the code decides. I'm the one who sets it: “only click the button if it's 90% confident.” If it's below that, I fall back to the old behavior, which is safe.
2. It's fast. About 0.9s per call, and you can send several questions in the same request.
3. There's no fragile JSON parsing. The answer already comes in the right format.
4. The probability becomes a business rule. You can adjust the confidence thresholds without touching any prompt.

Where NOT to use it

If you need to generate text (write a recipe, translate, summarize), then it's really LLM territory. Jev is for judgment: classifying, routing, verifying, choosing between options.

The rule I'm following:

LLM to write. Jev to decide. Code to execute.

Less giant prompts, less parsing breaking, and more predictable decisions.

That's it, folks! If you try Jev in some project, let me know how it went on Twitter or on LinkedIn.