A growing number of the AI systems I’m seeing aren’t trying to write paragraphs. They’re trying to make a call. And that sounds like a small difference, but it changes how you’d build around them. If your app needs to classify a failure, pick the next diagnostic step, weigh a risk, or just decide whether something should go ahead, a model that hands back structured decision data fits better than a general-purpose language model does. I’ve started calling these decision models, and once you name them, the design questions get sharper.
So what actually makes a model a “decision model”? It comes down to what its output means. A regular LLM generates text. A decision model takes a defined question in a given context and returns a choice, an assessment, or a probability. The output has defined semantics that software can consume directly. And here’s the part people miss: structured output isn’t enough on its own. A JSON blob that contains a generated explanation is still just generated text wearing a costume. The model has to be designed or configured around decision questions in the first place, and you measure it by decision quality, not fluency. Your application can still enforce policy and execute whatever action falls out of that.
The idea isn’t hard to picture. Say an automotive voice assistant hears “Play something from the Beatles.” It has to figure out whether the request is clear enough, what action is actually being asked for, and whether it’s allowed to just do it. Or a test framework chewing through system logs: real failure or expected response? Which category does it fall into? How bad is it? These are decisions software has to act on, often thousands of times an hour.
Three primitives worth knowing about
TypeSafe AI’s Jev exposes three kinds of decision questions: Choice, Score, and Noul. I find them a useful lens for how a decision model talks to ordinary software.
Choice picks one option from a fixed set. A test automation system might ask whether a failed voice interaction is a speech-recognition problem, a dialog-management problem, a backend-integration problem, or something weirder. The model returns its pick plus the probabilities on the alternatives.
Score rates a situation against an ordered scale (cosmetic to critical, say). Because the scale has order, you can actually do things with it: prioritize a backlog, trip an escalation threshold.
Noul is yes-or-no, but it gives you the probability of “yes.” “Does this failure look like a regression?” “Is this command clear enough to execute without asking?” You set a threshold and decide what happens below it: auto-proceed, ask for confirmation, or hand it to a human.
I’d be careful not to overstate these three as the taxonomy of decision models. They’re one practical interface, and a good one, but other systems produce rankings, multi-label outputs, numeric predictions, action sequences. Still, Choice/Score/Noul cover patterns that show up in a lot of business and engineering work.
One consequence I think matters architecturally: the model doesn’t have to own the workflow. The application defines what choices exist, what the scoring rubric is, under what conditions an action is allowed. The model evaluates context; conventional software does the executing, logging, enforcing. That separation is where a lot of the value lives.
What’s moving in this space
Jev is TypeSafe AI’s example of what they call a System One model, meaning structured decisions out instead of prose. Its interface lets you evaluate several decision questions against the same state in one request, which matters when you’re making lots of small judgments fast.
Cloudflare’s Clef is going at it from an adjacent angle, using decision models to support agentic systems and tool selection. Fastino has GLiDE, explicitly aimed at thinking and decision-making. Microsoft’s Decision-1 is another name worth keeping on the radar.
The pattern underneath all of this: a general-purpose reasoning model is still great for understanding something unfamiliar or sketching out a strategy. A specialized decision model can then answer narrower questions cheaper and faster. Stacking them is genuinely attractive when you need both flexibility and predictable interfaces.
One caveat I’d push on anyone selling me one of these: validate the performance claims against workloads that actually look like yours. Benchmarks are fine, but domain jargon, noisy logs, ambiguous inputs, and safety-sensitive calls are where models tend to fall apart in ways a leaderboard won’t show you.
Where this actually helps
Enterprise agent systems. A decision model can pick which tool handles a request, flag whether more info is needed, or check whether a proposed action stays inside policy. The agent’s reasoning can be as sprawling as it wants; the call to invoke a specific API can still be a narrow, typed question.
Automotive voice. Classify intent, judge ambiguity, decide if a clarification is warranted. Driver says “Turn it down”: volume? climate fan? something else? The final action still lives under the vehicle’s own software and safety constraints; the model just informs it.
Software engineering. An automated test system classifies unexpected responses, scores severity, estimates regression likelihood. If your framework correlates test observations with logs, these judgments help you triage, which matters when a test run spits out megabytes of data and an engineer only has time for a handful of findings.
Business processes too. Invoice processing: classify by department, score risk or urgency, decide if it needs human sign-off. The decisions slot into existing workflow engines without forcing a language model to generate and then interpret free-form instructions at every step.
You don’t always need a neural net for this
Honestly, not every decision problem calls for a specialized model. Depending on the shape of the problem, older tools do fine:
DMN (the Decision Model and Notation standard from OMG) gives you a formal way to describe business decisions. Drools is an open-source rule engine with DMN support, which is handy when the logic can be written down explicitly and owned by domain experts.
DEXi is open-source qualitative multi-criteria decision modeling. Nice when your decision hangs on several attributes and you want a transparent hierarchy of criteria.
Google OR-Tools handles scheduling, routing, assignment, constraint problems. These are “decision” in the mathematical sense; the machinery underneath is nothing like a neural model.
PyMC and scikit-learn cover probabilistic modeling and classic ML (classifiers, predictive models, statistical decision systems), with your application code deciding what to do with the predictions.
They sit at different points on the spectrum. Rules and DMN when you need explicitness and auditability. Optimization when constraints or an objective function drive the answer. Machine learning and specialized decision models when the evidence is messy, unstructured, or too hard to pin down in rules.
The bigger picture
I think the most interesting thing here isn’t any single model. It’s that a distinct decision layer is starting to show up in software architecture. Instead of stuffing every judgment into one big reasoning model, you can separate interpretation from decision-making from policy enforcement from execution. A reasoning model interprets the weird request or investigates the unfamiliar failure. A decision model answers a batch of narrow questions. Conventional software enforces thresholds, executes, records what happened. And the outcomes feed back into better criteria or better models.
For architects, that’s a real design space: how do you distribute decisions across models, rules, and deterministic code so the system stays adaptable without giving up control? That’s as much an architecture question as it is an AI one.
It hits hardest in systems that already produce structured observations and run automated workflows. Instead of treating every decision like a chat with a general-purpose LLM, you can start modeling decisions as explicit interfaces: defined outputs, measurable quality, someone clearly responsible for what happens next.