Jev vs LLMs

An LLM writes. Jev decides.

A general LLM like GPT or Claude is built to produce text. Jev is built to answer a question with one of the answers you allowed, and tell you how likely each one is. If your code needs to branch on the result, that's the difference that matters.

The same task, two ways

with a chat LLM

// Asking a chat model
const prompt = `Classify this ticket as billing, technical or sales.
Also rate frustration 0-2 and say if they'll churn.
Reply ONLY with JSON like {"team": ..., "frustration": ..., "churn": ...}`;

const text = await chat(prompt + ticket);
const out = JSON.parse(text);  // sometimes has ```json fences
                               // sometimes "Billing" vs "billing"
                               // sometimes "frustration": "medium"
                               // no idea how sure it was

with Jev

// Asking Jev
const { answers } = await jev({
  state: ticket,
  questions: {
    team: { type: "choice", instructions: "Which team handles this?",
            criteria: { billing: "...", technical: "...", sales: "..." } },
    frustration: { type: "score", instructions: "How frustrated?",
                   criteria: ["calm", "annoyed", "angry"] },
    churn: { type: "noul", instructions: "The customer is likely to cancel." },
  },
});

answers.team.choice          // always "billing" | "technical" | "sales"
answers.team.probabilities   // { billing: 0.91, technical: 0.07, sales: 0.02 }
answers.frustration.score    // 1.68, on your scale
answers.churn.noul           // 0.64

Side by side

	General LLM	Jev
What you get back	Free text you have to parse	A typed answer per question
Answer is always one of your options	Usually, if the prompt is good	Yes, by design
Probability of each option	No (or a made-up number in the text)	Yes, for every option
Confidence to set thresholds on	No	Yes
Many questions about one item	One long prompt, one long reply	One call, one answer each
Output tokens	Often hundreds (reasoning, JSON, fences)	A few per question
Writing, summarizing, chatting	Yes	No
Multi-step reasoning, tools, code	Yes	No

Why the probabilities matter

When a chat model says "billing", you don't know if it was 51% sure or 99% sure. Jev gives you the full distribution. That lets you:

Automate only the easy cases. Act when confidence is high and send the rest to a person.
Tune strictness without rewriting prompts. A spam filter can hide at 0.6 and just warn at 0.45. Change the number, not the prompt.
Rank things. Sort 10,000 leads by the probability of "great fit" instead of getting a pile of "yes" answers.
Measure it. Probabilities can be checked against labeled data, so you can see where it's right and where it isn't.

Why it's cheap

Most of an LLM's cost on a classification task is output: the reasoning, the JSON, the explanation you didn't ask for. Jev reads your input and returns a few numbers per question. A real call with three questions used 398 input tokens and 72 output tokens. That's why you can run it on every row, not just a sample.

When to use an LLM instead

You need text back: a reply, a summary, a rewrite, an explanation.
The answer isn't from a fixed set (extracting a name, a date, an address).
The task needs several steps of reasoning, tools, or code.

They also work well together: use Jev to decide whether to do something (is this worth replying to? is this request in scope? is this a prompt injection?), and an LLM to do it.

Try it on your own data

Open the playground