Where a decision model actually goes

Every document pipeline begins by deciding what arrived. Invoice, delivery note, contract amendment, or something unreadable that needs a person. Most teams do this with a small model call and a JSON schema, then spend weeks hardening the parser around it.

A typed choice with a confidence value removes the parsing problem entirely, because the output was never text. The threshold at which a case goes to a human becomes a tunable number rather than a heuristic buried in code.

In retrieval augmented generation the expensive failure is not the missing passage. It is the irrelevant one that gets synthesised into a confident wrong answer. Scoring each candidate for actual relevance before synthesis is the highest leverage guardrail in the pipeline, and the one most often skipped, because doing it per passage with a language model means an extra call per passage.

At sub cent pricing you score all of them, and not only for relevance: whether the passage supports the answer at all, whether it contradicts the question, whether it carries an injected instruction. That is four nouls on the same state. How the same layer is used in practice is in What developers are actually building with Jev.

Agentic systems spend a surprising share of their latency budget deciding which tool to call next. That decision is a choice from a fixed set. It does not need a reasoning trace. It needs to be correct and fast.

The durable part of the pattern is separating the axes: the answer says what was picked, the confidence says how sure. A reversible action may run at low confidence, an irreversible one may not. That turns a model call into gating logic that lives in code and can be reviewed there.

After a field is extracted, something has to judge whether it looks complete and plausible. Teams skip this, sample it, or route everything to a human. A calibrated score per field turns it into a threshold you can tune against an actual error budget instead of a feeling.

Policy checks are classifications too. They are typically applied only to requests someone flagged as risky, because applying them everywhere was too slow and too expensive. That constraint is largely gone.

Take one month of production classification calls and replay them. Compare accuracy and p95 latency against what runs today. Then look at the disagreements rather than the aggregate score, because the disagreements tell you whether the task was ever a language task. The test costs less than the meeting about whether to run it. The interface already sits inside common toolchains, for instance as the evaluate call in the AI SDK.

The bigger operational win is not the inference saving. Most B2B AI pipelines have thin observability, because evaluating each step costs another model call and nobody budgets for that. When evaluation drops to a rounding error, you can score every step of every run, keep the distribution, and see drift before a user reports it.

The pattern does not fit anything that has to produce a reason, write to a person, or reach outside the state you supply. A decision model has no world knowledge and no rationale. Sending it work that needs either is how a first pilot fails.