What's a decision model?

People make a lot of decisions. Like where to go to dinner or what movie to watch. They also need to determine if chili is a soup?

Another thing people do is use LLMs a lot. LLMs take text as an input and they output a lot of text. For example, you could ask an LLM if chili is a soup.

And it will output something like:

The debate is real: there’s no agreement on if chili is a liquid based meat dish, it is most likely a soup. You’re absolutely right. It’s not that chili isn’t a soup – it’s that soup is chili. Meat or no meat is the load bearing question. Would you like me to turn this into a sloppy website or should I hack HuggingFace again or should I post that third pic of your feet on Linkedin?

And so you can get an answer, but it’s not yes or no. It is:

• Verbose: it’s generating a bunch of text and extra tokens
• Slow: inference here is going to take time when you just want a quicky
• Expensive: bunch of token I/O here you’re going to spend $$$ to scale this
• Not the right task: LLMs predict the next token in a series when all we want is a single token (yes / no) and the soft max of its logit (yes% / no%)

We could alter our prompt a bit and say: “Is chili a soup, only respond with yes or no and the associated confidence in that answer.” And then you’ll get something like “Yes, 80% confidence.” But we still have a few problems.

• We still received a text blob when really this should be a Boolean value (yes/no)
• This is still slow
• This is still expensive

Making LLMs deterministic#

What we really want is to chop the top on this thing and generate probabilistic responses over token output, do it quickly, and return a deterministic value (yes/no in this case). Thus, we have catapulted ourselves into a… “decision model”.

On September 15th, 2026, typesafe released Jev. Jev was the first decision model to catch mainstream attention (it turns out good research requires good marketing). Typesafe claims it to be “193.6x faster, 444.6x cheaper” than an LLM. The idea is that if you need fast, intuitive, cheap, and hallucination proof thinking about chili… my name Jev.

The second transformer is named Erector by the way.

Wait…why do I care? And why is this cheaper?#

Jev costs $.042 per million input tokens and charges nothing for output because it is “too cheap to meter”.

Frontier LLMs charge more for output than input, the opposite of Jev. Even when we constrain an LLM to a single token output, we are still doing a forward pass across billions of parameters, performing reasoning, and producing a token.

While Typesafe hasn’t released their specific architecture, stuff like kev, Qwen-2.5-1B-RLCD, and OpenAI’s decisions API point to tuning an LLM and altering its head to only return the underlying probabilities associated with the available choices (rather than outputting tokens directly).

To be fair, this is a bit of a silly comparison because Jev is not an LLM, and is optimizing for a completely different set of tasks.

LLMs spend a lot of time and effort predicting the next token or word in a sequence that is most pleasing to a human, which is a technique commonly referred to as Reinforcement Learning from Human Feedback (RLHF).

RLHF -> RLCD#

Rather than incentivize human approval and text generation, the folks at Typesafe leverage what they call “Reinforcement Learning for Calibrated Decisions” (RLCD) where the model is incentivized to return well calibrated probabilities.

So when asked “is chili a soup?” it returns a probability distribution across the available choices (yes or no). This type of question is interestingly called a “noul”; Typesafe supports several types of questions:

I hope to have painted a chili picasso in your mind.

As the sauce drips down the tub and the beans squish between your toes, you realize that decision models are geared towards system to system interaction: interactions that need to be quick and deterministic.

If you go to Chase Bank and attempt to deposit a pot of chili you’re going to get arrested. Banks take money, you’d need to convert that chili into money before depositing. To convert the chili, you could take pictures of yourself in the chili bath and sell them on ONLYChili, generating depositable cash.

Software systems also require specific currencies in the form of types, making typed responses all the more important… hence the name ”typesafe”.

What else can I do with a decision model? #

Can we ask Jev which NFL team will win the superbowl? Can we give Jev access to my Tinder and have it swipe left/right based on my preferences?

No need for complex sports models or tinder bots, I’ll finally be able to quit my day job and find love for less than a cent.

Unfortunately, decision models aren’t black magic.

They are essentially performing classification based on the underlying pretrained model and the activations derived from the state/question provided at inference time.

The old way (classification models)#

Classification is a branch of machine learning where we label things, or create groups of like items. For example, I could take reviews of my chili and classify them as “positive” or “negative”.

For any particular problem there are different tools one could choose from to perform this classification: logistic regression, k nearest neighbors, support vector machines, neural networks, etc.

You pick a technique, feed some pre-labeled examples to train it {“this chili sucked” : negative}, {“I’d crash my car for this chili : positive”}, and you’ve got a model.

This isn’t ML 101 so I’m not going to go full Khan academy, but you can probably see how there’s a variety of use cases for this kind of classification.

You could also see how it might take time to:

1. select a model
2. gather up training data
3. clean the training data
4. hop on a quick call
5. train the model
6. Tim is pissed because you didn’t fill out all the custom fields in Jira
7. test the model for accuracy
8. join the hour long team standup…

If you could simply throw this task at a decision model you could save a lot of time. A pre-trained, universal classifier that can match or beat a custom one would be cool.

It would be extra cool if it was cheap, and I might take up smoking if it could handle non-trivial problems like determining whether an incident needs to be escalated. However, there is plenty to take care of before I start ripping 6 packs a day.

Problems with a universal decision model#

Decision models are a black box, arriving at a percentage is interesting but will often lead to the question: “why?”.

You can dissect many machine learning techniques, inspect your training data, and figure out what is occurring, but this becomes more difficult with decision models and LLMs in general.

The other question is whether or not a decision model will be able to beat a model trained for a specific problem.

One issue with Jev is calibration. Calibration is the alignment between a model's confidence (probability) and the actual long-run frequency of that thing happening.

Jev is… not that well calibrated and it doesn’t roll dice very well. Typesafe readily admits there are some “jagged edges”. It’s important to remember that these models are… models, they improve with better architectures and training data.

Different models have specific purposes, a frontier LLM is great at reasoning over problems with massive context windows and hacking huggingface while decision models are geared towards fast/intuitive tasks (system one).

There is a universal, fast, cheap triangle, and you can’t have all three.

One area where decision models are being embedded is at the analytics layer, with Motherduck and Databricks embedding a “prompt the decision model” function to perform quick classification.

There’s clearly an appetite for this kind of reasoning, only slightly less than my appetite for chili and egg beers.