What is an AI decision model?

An AI decision model reads an input and returns an answer from a set you define: one option from a list, a score on a scale, or the probability that something is true. Every allowed answer comes with a calibrated probability, in one pass, and nothing is generated.

Since TypeSafe AI released Jev in September 2026, models of this kind are also called System One models. The name comes from Daniel Kahneman's two systems of thought. System 1 is fast, automatic judgement; System 2 is slow, written-out reasoning. A language model working through a problem imitates System 2. A decision model does the other job: it returns the answer your code needs, directly.

An example

A support ticket arrives, and your code needs two decisions: which team gets it, and whether it is urgent. You send the ticket as the state, with two typed questions. The shape below is illustrative; each model's page shows its exact format.

{
  "state": "I was charged twice for my September invoice and my card is now over its limit.",
  "questions": {
    "team": { "type": "choice", "options": ["billing", "technical", "sales"] },
    "urgent": { "type": "noul", "condition": "The customer needs help today" }
  }
}

The answer is one value per question, with a probability for every allowed answer:

{
  "team": { "choice": "billing", "probabilities": { "billing": 0.94, "technical": 0.04, "sales": 0.02 } },
  "urgent": { "noul": 0.81 }
}

Nothing to parse, no way to answer outside the options, and a number you can put a threshold on.

How it works

A decision model reads the state and the questions once. Instead of producing text token by token, a decision head scores each allowed answer, and a softmax turns the scores into probabilities. Training rewards probabilities that match how often the answer is right, not just the right answer, which is what makes them calibrated.

The open models come in two families, and the registry lets you filter by them:

• Native models put a decision head on an encoder. Laya and Von use ModernBERT-large; Julia 1 uses mmBERT-small at 144M parameters. They are small and fast, often a few tens of milliseconds a decision on a GPU.
• LLM decision models start from a language model and read the answer from its output, usually after a LoRA fine-tune. Kev, Bespoke-Nimble-9B and Decider are built on Qwen3.5. They are larger, and they bring the language model's knowledge with them.

The three kinds of question

• Choice: pick one option from a list you send. Route this ticket to billing, technical or sales.
• Score: place the state on a scale you define. Rate this lead from 1 to 5, with a description for each level.
• Noul: the probability that a condition holds. Is this tool call safe to run?

Because the questions arrive with each request, one model answers questions it was never trained on. That is the difference from a classifier.

Why the probability matters

A calibrated model that says 0.9 is right about nine times in ten. That makes the probability useful: act automatically above a threshold, and send everything below it to a person or a larger model. This pattern is called confidence gating, and it is how decision models go into production without every answer being checked. How well a model's probabilities match reality is measured as expected calibration error; lower is better.

How it differs from what you'd use instead

An LLM writes. Its answer has to be parsed, can come back off-schema, and takes longer the more it writes. Ask it for a probability and you get more text. A decision model selects from your answers in a single forward pass, usually in milliseconds.

A classifier also returns a label with a probability, but its labels are fixed when it is trained. A new question means new training data and a new model. A decision model takes the question with each request.

JSON mode or structured outputs make an LLM's output parse. It is still generation, just as slow, and the value inside has no calibrated confidence. A decision model returns a distribution over the allowed answers.

When to use one, and when not to

Use one where software makes the same kind of decision many times: routing tickets and requests, guardrails on tool calls and replies, scoring leads or documents, and the small choices an agent makes on every step. Speed and cost per call matter there, and the answers come from a set you know.

Don't use one when you need an explanation, a written reply, or an answer that isn't in a list you can write down. That is still a language model's job. Often the two work together: the decision model handles the common cases quickly, and hands the uncertain ones to the LLM.

Other names for the same thing

Besides System One models and AI decision models, you will see typed decision models, System 1 models, Jev-style models and Jev alternatives. In business analytics, "decision model" also means a decision table or a DMN diagram. That is a different thing.

Try one

Every model on the registry has a playground: pick a model, write a state and a question, and see the decision and its probabilities. To run one yourself:

pip install systemonemodels
systemone pull convai-innovations/laya

AI decision models compares them with LLMs, classifiers and JSON mode side by side; Every System One model lists them all with sizes, licences and reported benchmarks; and Open-source Jev alternatives is the list of the ones you can run yourself.