Today I was reading about Jev, and one idea genuinely stopped me.
We usually think about AI inference in a very familiar way:
Prompt → generate tokens → get an answer.
But what if the model doesn't need to generate an answer at all?
What if the output isn't a paragraph, an explanation, or even a piece of JSON?
What if the output is simply the decision?
That's what I found interesting about Jev.
Instead of thinking about inference as:
Input → Generate text → Parse the response → Extract the decision
Jev's decision-oriented approach can be thought of as:
Input → Make a decision → Return the probability
And that sounds like a small difference until you start thinking about where this could actually be useful.
Imagine a testing system processing thousands of test failures.
Instead of asking an LLM:
"Analyze this failure and explain whether this is a regression."
you could think about the actual decision the system needs:
Is this a real regression? → 94%
Should this test be retried? → 8%
Does this need human review? → 91%
The model isn't writing an explanation and leaving the application to figure out what it meant.
The decision itself becomes the output.
That distinction got me thinking about how often we use generative AI for problems that aren't really generative problems.
A QA system doesn't necessarily need an essay about a failed test.
A fraud detection system doesn't need a paragraph explaining every transaction.
A monitoring system doesn't need a beautifully written response every time an anomaly appears.
Sometimes the software just needs a decision.
And this is where Jev's three basic decision types become interesting:
Choice → choose between options
Score → assign a numerical score
Noul → make a true/false type decision
These sound simple, but they map surprisingly well to the kinds of decisions software makes constantly.
Which category does this belong to?
How relevant is this?
Should this be retried?
Is this suspicious?
Does this need human intervention?
Which route should this request take?
In many of these cases, natural language isn't actually the final product.
The decision is.
But then I came across the part I found even more interesting: probability.
It's easy for a model to say:
"I'm 80% confident."
But the interesting question isn't whether the model can produce the number 0.8.
The interesting question is whether that 0.8 actually means something.
This is where calibration comes in.
If a model makes a large number of predictions with an estimated probability of 80%, then a well-calibrated system should be correct on roughly 80% of those cases.
So probability becomes more than a confidence label.
It becomes a signal that the rest of the system can use.
Imagine an automated QA workflow:
A test failure gets a 97% regression probability.
Another gets 61%.
Another gets 12%.
Those aren't just three predictions. They can represent three different levels of certainty, which means the software can potentially treat them differently.
High-confidence decisions can be automated.
Uncertain decisions can be routed for human review.
Low-confidence decisions can be ignored or handled differently.
The exact thresholds depend on the application, but the important part is that uncertainty becomes part of the interface between the model and the software.
And then I started thinking about something else.
Even when we ask an LLM to return structured JSON, we're still using a generative model to produce that structure.
For example:
{
"is_regression": true,
"confidence": 0.94
}
It looks like a structured decision to us.
But the model still generates the tokens that make up that JSON. The application receives that generated output and then parses it to extract the fields it actually needs.
So even though we've constrained the output format, the underlying interaction is still fundamentally generative.
That's what makes the decision-oriented approach interesting to me.
The question changes from:
"What should the model generate?"
to:
"What decision does the application need?"
And that's a much more interesting way to think about AI inference for certain types of systems.
Not every AI problem is a content-generation problem.
Sometimes the model doesn't need to write.
It needs to classify.
It needs to choose.
It needs to score.
It needs to say yes or no.
And ideally, it needs to tell the system how certain that decision is.
The more I thought about it, the more use cases started coming to mind: QA, fraud detection, anomaly monitoring, routing, ranking, classification, moderation, and pretty much any workflow where the final consumer of the model's output is another piece of software rather than a human reading a response.
That led me to a very simple way of thinking about the difference:
LLMs → Generate
Jev → Decide
Of course, LLMs can also be used for classification and decision-making, so the distinction isn't that simple technically.
What I found interesting is the abstraction.
We're so used to thinking about AI as something that talks to us.
Jev made me think about AI as something that can simply make a decision for a system.
And honestly, I hadn't thought about AI inference from that angle before.
Maybe AI doesn't always need to talk.
Sometimes, you just need it to decide.
Top comments (0)