What's Jev, System One and Discriminative Models
AI doesn’t always need to write long answers.
Sometimes, you just need it to make a fast, reliable decision: Is this ticket about billing? Should this request go to the backend agent? Is this command safe?
That’s where Jev, System One, and discriminative decision models become interesting for developers. They’re here to handle the parts where an LLM may be too slow, too expensive, or too unpredictable.
System One Means Fast Decisions #
The idea of System One comes from Daniel Kahneman’s book Thinking, Fast and Slow. In simple terms:
- System One: fast, instinctive decisions
- System Two: slower reasoning, planning, and deep thinking
Yugo explained it like this:
System One is when you think fast. System Two is when you have to think slower, and it requires reasoning.
Large language models, like GPT-style models, are closer to System Two. They generate text step by step. That’s useful for writing, planning, coding, and analysis.
But if you only need to choose between known options, you may not need a full generative model.
What Is Jev? #
Jev is a hosted service for decision models. It became popular because it focuses on fast, structured decisions instead of free-form text generation.
The name comes from Jevons Paradox. That’s the idea that when something becomes cheaper or easier to use, people may use it more, not less.
In this case, if decisions become much cheaper and faster, developers may start using AI decisions in many more places.
Generative vs Discriminative Models #
A normal LLM is generative. It creates text token by token. That means it can:
- write an answer
- explain an idea
- draft an email
- generate code
- hallucinate
- return the wrong format
A discriminative model is different. It chooses or scores from options you give it.
Yugo described the key difference clearly:
It won’t generate anything. It will just calculate the probabilities given these criteria.
Think of it like a smarter if statement:
Input: "I can't update my payment method and I'm very frustrated."
Options:
- Billing
- Cancellation
- Technical Support
Output:
- Billing: high probability
You give the model:
- The input text
- The question
- The allowed answers
And it returns a decision, usually with probabilities.
Why Developers Should Care #
Many teams already use LLMs for classification. For example:
Read this support ticket and return one of these categories:
billing, cancellation, technical_support
But this can be fragile. The model might return:
This looks like a billing problem.
Instead of:
{ "category": "billing" }
Now your code needs parsing, retries, validation, and error handling.
Decision models reduce this problem because the output is constrained. Yugo said:
Since the outcome is always a specific format, you don’t have the problem of parsing the response and handling those errors.
Common Use Cases #
Decision models are useful when you already know the possible answers.
Good examples include:
- Routing: choose which agent should handle a request
- Classification: label a ticket, document, or issue
- Safety checks: decide if a command is safe to run
- Guardrails: block or allow user input
- Scoring: rate urgency, sentiment, or risk
- Triage: send support tickets to the right team
For multi-agent systems, this is especially useful. Instead of asking a large model to decide which agent should answer, a decision model can make that choice faster and cheaper.
Routing for multi-agents is a very common use case. You have many agents, and you need to decide which one should answer the user’s question.
The Practical Mental Model #
Use this simple rule:
- Use an LLM when you need creation, explanation, or reasoning.
- Use a decision model when you need selection, classification, or scoring.
For example:
Decision model:
"Should this go to the billing agent or support agent?"
LLM:
"Write a helpful reply to the customer."
They work best together. The decision model chooses the path. The LLM does the creative or reasoning-heavy work.
What About Accuracy? #
Decision models still need testing. Probabilities don’t automatically mean the answer is correct.
You should create a golden dataset. That’s a set of examples where you already know the correct answer.
Then test the model against it:
- Does it classify known examples correctly?
- Does it behave well with real user text?
- Are the probabilities useful?
- Does it fail in risky cases?
If it performs well on your dataset, you can trust it more in production.
Cost And Performance Matter #
Jev claims big performance and cost benefits compared to large language models.
The important point: don’t compare them as if they do the same job.
Final Thoughts #
Jev and System One models are not magic, and they won’t replace LLMs. But they can make AI systems faster, cheaper, and easier to control.