How To Use Decision Models for Evals

main.content table { display:block; width:100%; max-width:100%; overflow-x:auto; } #evaluation-prompt pre { background:var(--bs-body-bg); color:var(--bs-body-color); padding:18px; border:1px solid var(--bs-border-color); border-radius:6px; } #evaluation-prompt pre code { color:inherit; white-space:pre-wrap; overflow-wrap:anywhere; } Decision models have exploded onto the scene recently, starting with TypeSafe’s Jev, followed by Perplexity’s Decider, Liquid’s d1, Cloudflare’s Clef, and OpenAI’s Decisions API1. These models promise fast, inexpensive classification. Decision models are an appealing low-cost alternative to LLM judges2 for automated evals. But whether they’re the right choice depends on the cost, performance, and latency requirements of your use case. We’ve also noticed people using the default decision threshold of 0.50 without checking whether it works well for their task. This can leave a lot of performance on the table. In this post, we’ll start by showing how to tune thresholds to get the best results from decision models. With those thresholds tuned, we’ll compare cost and performance to help you assess which model fits your use case. Finally, we’ll explore how to interpret model scores when deciding whether to act, and how calibration can make them more useful as confidence estimates. What we tested We used 100 traces, or logs of conversations and actions, from an apartment leasing agent. The task is to identify traces containing an error, such as a failed booking or a missed handoff to a human.3 We used the same dataset and broad failure-finding task in our prior post on automated evals. Here, each decision model returns a failure probability for each trace. We tested Jev 1.13, Perplexity Decider 1.1 27B, Liquid d1 and d1-ultra, Cloudflare Clef Flash, and OpenAI Decisions (GPT-6 Luna)1. Each model received the same evaluation criteria. The appendix shows the prompt and the structured version used for Jev. We compare models on two dimensions: Performance: We compare each model’s predictions with traces that people have reviewed and labeled as passing or failing. This measures how well the model catches failures while avoiding false alarms. Cost: We calculate API cost from token usage and the provider’s prices.4 For brevity, we leave latency aside because it depends on factors outside this experiment’s control.5 Understanding decision thresholds We assign each trace one of two labels, pass or fail. This is a binary pass/fail eval, which we recommend because it encourages clear criteria and is easier to align with human preferences. Each decision model returns a score from 0 to 1 that estimates how likely a trace is to contain a failure. The APIs turn this score into a decision using a default decision threshold of 0.50. Traces with scores at or above the threshold are flagged as failures. Using this default without checking it against your data can give you subpar results. For example, a model could assign every failure a score of 0.40 and every passing trace a score of 0.10. Even though this model classifies traces perfectly at a threshold of 0.30, the default threshold of 0.50 would catch nothing. In practice, scores for failures and passing traces will overlap. Lowering the threshold catches more failures but can also raise more false alarms. Choosing a threshold means balancing: Precision: The share of flagged traces that contain a known failure. Recall: The share of known failures that the model catches. The right tradeoff depends on your business goals. For example, criminal trials set a high bar for conviction to avoid convicting innocent people, emphasizing precision. Cancer screening may emphasize recall, accepting more false alarms to miss fewer cases.6 For this comparison, we’ll give precision and recall equal weight using the F1 score, their harmonic mean. F1 ranges from 0 to 1, and higher is better. The curves below show how each model scores failures (orange) and passing traces (blue). Taller parts of a curve mean more scores from that class fall in that range. Scores at or above the dashed threshold line are flagged. Use the toggle to compare 0.50 with Optimized for best F1, which chooses a threshold for each model.7 (() => { const frame = document.querySelector('.eval-score-frame'); const fit = () => { try { const content = frame.contentDocument.querySelector('main'); const resize = () => { frame.style.height = Math.ceil(content.getBoundingClientRect().height + 4) + 'px'; }; resize(); new ResizeObserver(resize).observe(content); } catch (_) { /* Keep the fallback height for file previews. */ } }; frame.addEventListener('load', fit); if (frame.contentDocument?.readyState === 'complete') fit(); })(); OpenAI separates the two classes best on this task, which is also reflected in its higher F1 score. It’s also important not to blindly maximize F1 without thinking about your minimum requirements for the classifier to be useful. For example, if this classifier is used for an automated alerting system, I would want a minimum of 80% on both precision and recall so that I’m minimizing false alarms while catching a sufficient number of failures. The chart below shows how precision and recall change at different thresholds.8 The shaded region marks where both reach at least 80%. (() => { const frame = document.querySelector('.precision-recall-frame'); const fit = () => { try { const content = frame.contentDocument.querySelector('main'); const resize = () => { frame.style.height = Math.ceil(content.getBoundingClientRect().height + 4) + 'px'; }; resize(); new ResizeObserver(resize).observe(content); } catch (_) { /* Keep the fallback height for file previews. */ } }; frame.addEventListener('load', fit); if (frame.contentDocument?.readyState === 'complete') fit(); })(); Perplexity, Liquid d1-ultra, and OpenAI Decisions meet our requirements, but we still need to choose a decision threshold within the shaded region for each model. In the next section, we’ll discuss how to tune those thresholds. Tuning the decision threshold For this example, we’ll optimize F1. For our candidates, we’ll restrict tuning to thresholds that meet both 80% minimums on the training data whenever possible. We leave the other models unconstrained to illustrate the effect of tuning.9 With labeled traces and saved model scores, you can ask a coding agent to tune the thresholds. Below is an example prompt you can modify for your use case: Using my saved model scores and binary labels (1 means failure), tune a decision threshold to maximize F1 while requiring at least 80% precision and 80% recall. Use stratified five-fold cross-validation, choosing thresholds on the training examples and measuring performance on the remaining examples. If comparing models, use the same splits for each. Only select thresholds that meet both minimums on the training examples. If none qualifies, report that rather than relaxing either requirement. Report validation precision, recall, and F1, along with any splits where no threshold qualified or validation performance fell below my minimums. Compare with the default threshold of 0.50. Reuse the saved scores without making new model calls. Here’s how tuning for F1 changed each model’s performance. We group the three candidates from the precision-recall chart together and show the other models in gray to illustrate how much tuning can help. (() => { const frame = document.querySelector('.threshold-impact-frame'); const fit = () => { try { const content = frame.contentDocument.querySelector('main'); const resize = () => { frame.style.height = Math.ceil(content.getBoundingClientRect().height + 4) + 'px'; }; resize(); new ResizeObserver(resize).observe(content); } catch (_) { /* Keep the fallback height for file previews. */ } }; frame.addEventListener('load', fit); if (frame.contentDocument?.readyState === 'complete') fit(); })(); Our candidate models gained less from F1 tuning than Liquid d1 and Clef Flash, which fell below our minimums. However, even a small shift in precision and recall can affect business costs or the user experience, so choose the tradeoff deliberately. In practice, it’s unlikely that precision and recall are equally important (as we assumed in this post with F1). For example, the F-beta score lets you give precision more weight with beta below 1, or recall more weight with beta above 1. Optimizing a different metric could lead to different thresholds and results. Performance versus cost The chart below compares each model’s F1 (after tuning) against cost, focused on our remaining candidates: (() => { const frame = document.querySelector('.cost-comparison-frame'); const fit = () => { try { const content = frame.contentDocument.querySelector('main'); const resize = () => { frame.style.height = Math.ceil(content.getBoundingClientRect().height + 4) + 'px'; }; resize(); new ResizeObserver(resize).observe(content); } catch (_) { /* Keep the fallback height for file previews. */ } }; frame.addEventListener('load', fit); if (frame.contentDocument?.readyState === 'complete') fit(); })(); The dashed line shows the Pareto frontier among our remaining candidates. For any given F1 score, it identifies the cheapest candidate that meets or exceeds that score. This particular chart is a bit silly as there are only three options, but it’s a useful illustration for how to think about cost vs. performance. Perplexity was the cheapest of these candidates at 0.82 cents per 100 eval runs, with an F1 of 0.79. OpenAI Decisions reached an F1 of 0.87 at 3.72 cents per 100 eval runs, about 4.5 times the cost. Can we trust the probabilities? Beyond pass/fail evals, you may want to use a decision model’s score as a confidence estimate. But can you take that number literally? For a score of 0.80 to mean an 80% chance of failure, roughly 80% of traces with similar scores should contain failures. The chart below s