All chapters
  1. Start hereA test checks an answer. An eval measures a behavior
  2. Foundations · 1Primitives: the small words every eval is built from
  3. Foundations · 2Grading and rubrics: who decides what good means
  4. Foundations · 3Golden datasets: the cases you trust
  5. Mechanics · 4What to evaluate: the answer, the path, and what was left behind
  6. Mechanics · 5Agent traces: the record you grade the path from
  7. Mechanics · 6Judges and calibration: when a model grades a model
  8. Mechanics · 7Confidence and uncertainty: five numbers that are not the same
  9. Mechanics · 8Reliability and statistics: one run proves little
  10. Systems · 9The eval harness: the program that runs the evals
  11. Systems · 10CI/CD quality gates: which evals may block a release
  12. Systems · 11Production evals: measuring what real traffic does
  13. Reference · 12Frameworks: what each eval tool runs for you
  14. Reference · 13The insurance lab: ten cases, end to end
  15. Reference · 14Advanced topics: where evals themselves fail
  16. ReferenceGlossary
  17. AboutAbout this site and its sources
Mechanics · 7

Confidence and uncertainty: five numbers that are not the same

A model's stated confidence, a grader's score, a retrieval similarity, a measured success rate and a risk score all look like 0.8. What each one is, and what none of them is.

Five numbers
You will tell apart five numbers that all look like 0.8, and say who made each one and what it is about.
One check
You will check a model's claim about itself with a small table and one sum, by hand.
One limit
You will know what a model's own confidence cannot tell you, and what to use next to it.

Picture an underwriter opening a submission in the underwriter cockpit, the web app where recommendations wait for a decision. A broker has asked for cover on a masonry office in wind zone C. The underwriting agent has read the submission and written a recommendation: approve. The model recommends; a person decides. So the underwriter looks for something that says how far to trust it, and the screen offers five numbers.

Two of them read 0.90: one says the agent is 0.90 confident, one says a grader gave 0.90. The other three read 0.50, 0.80 and 0.59. Nothing on the screen is red.

The recommendation is wrong. This is trial 2 of case UW-010 in the example. The application says the roof is 9 years old. An outside provider says 22. Under the policy fixture (the illustrative rule set of the example), a gap of more than 5 years must go to a senior underwriter: the expected result is escalate, citing rule R-ROOF-03. In this trial the agent dropped the provider's answer and saw only the 9.

No number on the screen was false. Each reported what it was built to report. But none of the five answers the underwriter's question, "is this recommendation right?", and their shape hides that. A number between 0 and 1 looks like a probability, whoever made it.

A score is an observed result. Confidence is a claim about uncertainty. Reliability needs repeated evidence.

One note before the numbers: the agent here is a scripted stand-in, so these results show how the evaluation works, not how good any model is. Every value on this page is synthetic.

1. One trial, five numbers#

Take the five in the order they come into being. Of each, ask who made it and what it is about.

The agent's own claim#

When the agent writes its recommendation, it also writes how sure it is. That is one field in its output, "stated_confidence": 0.9. A model produces this number the way it produces every other word of its answer. Nothing checked it. This site calls it the stated confidence and never shortens that to "confidence", a word that invites the reader to hear "probability of being right".

The search step's number#

Before writing, the agent searched the insurer's guidance. A search returns passages, and attaches to each a number that says how much the passage resembles the query. That number is the retrieval similarity. In the example, search_guidance computes it as the share of query words that appear in the passage. Production systems commonly compare embeddings instead (an embedding is a list of numbers that stands for the meaning of a text). Either way, the number compares two texts. In this trial the top passage scores 0.50.

The business rule's number#

The eligibility check also returns a risk score: a number that plain code computes from the facts of the submission to say how much is at stake. Older roof, higher wind zone, more past losses: higher score. It describes the building. It knows nothing about the agent. Here it is 0.59.

The grader's number#

After the trial ends, graders look at it. One of them, the rubric grader from Grading and rubrics, reads the written reasons and gives a score: the observed result of grading this one trial. The reasons in trial 2 are clear and complete for what the agent saw, so the rubric score is 0.90. A different grader, recommendation_match, fails the trial. Two graders, two questions.

The number that needs many trials#

UW-010 runs the same submission 20 times. 16 trials escalate and pass every grader. 4 recommend approve and fail. The measured success rate is 16 of 20, or 0.80. It is the only one of the five that was counted from outcomes, and it is about the case across trials, not about trial 2.

All five, side by side#

The lab below shows the five for any of the 20 trials. Pick a passing trial, then a failing one, and watch which meters move.

The same information as a table, with the values of trial 2 (fails) and trial 1 (passes):

NumberWho produces itWhat it meansWhat it does not meanTrial 2Trial 1
Stated confidenceThe agent, in its outputWhat the model says about its own answerThat the answer is right this often0.900.80
Grader scoreThe rubric grader, after the trialHow well the written reasons meet the rubricThe chance that the recommendation is correct0.901.00
Retrieval similarityThe search step, during the trialHow close the top passage is to the queryThat the passage is the right rule0.500.50
Measured success rateThe eval harness, over 20 trialsHow often this case passed when repeatedAnything about one given trial0.800.80
Risk scoreA business rule, in codeHow much is at stake in the submissionWhether the agent is right0.590.72

Read the two right-hand columns against each other. The failing trial has the higher stated confidence, a grader score well above the rubric's pass line, the same retrieval similarity and the lower risk score. Sort these two trials by any single number on the screen, and the wrong one does not sink.

Diagram: Five numbers, five makers, one screen

Read left to right. Three numbers are made inside one trial, by three different things. One is made after the trial, by a grader. One exists only after many trials. All five are between 0 and 1, so on a screen they look like the same kind of number. The values in the examples come from trial 2 of UW-010 in the example run and are synthetic.

  1. 1 · Inside one trial
    1. Stated confidence: The number the agent puts in its own output about its own answer. A claim, not a measurement.
    2. Retrieval similarity: How close a retrieved passage is to the query text. It describes the search, not the answer.
    3. Risk score: How much is at stake in this submission, computed by code from the facts it is given.
  2. 2 · After the trial
    1. Grader score: The observed result of grading this one trial against the rubric for the written reasons.
  3. 3 · After many trials
    1. Measured success rate: The share of trials of this case that passed every grader. Evidence about the case, not about one trial.
  4. 4 · One screen
    1. Five numbers side by side: Where the confusion starts: nothing in the digits says who made each number or what it is about.

The diagram shows why. The five numbers have five makers, and they are made at three different moments. The screen is the only place where they meet.

2. Why no number can stand in for another#

Each number fails at another number's job. The example run recorded how.

The stated confidence is higher on the wrong trials. In the example it comes from a scripted table in agent_sim.py: 0.90 for approve and decline, 0.80 for escalate, 0.70 for request_info. The four failing trials recommend approve, so they state 0.90. The 16 correct ones escalate and state 0.80. A real model is not a table, but it shares the mechanism: an agent states confidence about the facts in front of it. With the provider's answer dropped, a nine-year-old roof makes approve an easy call.

The grader score is high on a wrong recommendation, because the rubric grades the reasons and not the recommendation. That is by design, so that each failure has a name. It also means the rubric score can never be read alone.

Common confusion. A rubric score of 0.90 does not mean "90% likely to be correct". A rubric score is never the probability that a recommendation is correct. It is the observed result of one grader on one trial.

The retrieval similarity did not move between trials, because the query was the same. It also did not point at the right rule. The top passage, at 0.50, is R-ROOF-01, the rule about roofs older than 25 years. The rule that decides this case, R-ROOF-03, scores 0.25.

The risk score moved in the wrong direction. The risk rule is deterministic code, but it runs on the facts the agent hands it. With the provider's 22 years it returns 0.72. Without them it sees 9 years and returns 0.59. The agent's mistake made the building look safer. A business number computed downstream of an agent inherits the agent's omissions.

The measured success rate is honest about the case and silent about the trial. 0.80 says that when this submission was run 20 times, 16 runs passed. It cannot say which kind trial 2 is. And 20 trials leave real doubt about the rate itself: the range of rates that fit this evidence runs from 0.58 to 0.92, which the next page explains.

Production pitfall. A dashboard column named "confidence" will be filled with whichever of these five numbers was nearest to hand, and read as the probability of being right. Name every column by its maker: stated confidence, rubric score, retrieval similarity, pass rate over n trials, risk score.

For the same reason, do not multiply or average these numbers into one "trust score". The product of a similarity and a rubric score has no meaning that anyone can check.

3. Calibration: checking a claim against what happened#

Of the five, the stated confidence is the one people most want to use, because it arrives free with every answer. So the fair question is: can a claim like "0.90" be checked?

It can, the same way a weather forecast is checked. A forecaster says "70% chance of rain" on ten different days. Nobody can say whether one of those forecasts was right; it rained or it did not. But over the ten days you can count. If it rained on seven, the forecaster's "70%" meant what it said. If it rained on three, it did not.

A stated confidence is checked the same way. Collect many recommendations, each with its stated confidence and with a label that says whether it was right. The label comes from people: it is the expected result of a golden case (a case whose expected result people agreed on), from Golden datasets. Group the recommendations by stated value. In each group, count how many were right.

When the stated value and the observed share agree in every group, the stated confidence is calibrated. The table that shows the comparison is called a reliability table.

Here is one. These numbers are illustrative: invented for this page so that the arithmetic is easy to follow. They do not come from the example run or from any model. Imagine 100 recommendations.

Stated confidenceRecommendationsRightObserved share rightGap
0.601060.600.00
0.7020130.650.05
0.8030210.700.10
0.9040280.700.20
All100680.68

Read it row by row. When this imagined agent says 0.60, it is right 6 times in 10: the claim holds. When it says 0.90, it is right 28 times in 40, which is 0.70: the claim is 0.20 too high. The gap grows as the stated value grows. This agent is overconfident, and most overconfident where it sounds most sure.

The word has a second use on this site. Judges and calibration calibrates a judge: it checks a model's grades against human labels. Here the thing checked is the agent's claim about its own answer.

4. Expected calibration error: the table in one number#

A table is good for reading and awkward for tracking. To compare two prompts, or to watch one agent over months, people want one number for the whole table.

The idea is plain: average the gaps, but let a row that holds many recommendations count for more than a row that holds few. That average is the expected calibration error. For each row, multiply the row's share of all recommendations by the row's gap. Then add the results.

On the illustrative table:

StatedShare of the 100GapShare × gap
0.6010 of 100 = 0.100.000.000
0.7020 of 100 = 0.200.050.010
0.8030 of 100 = 0.300.100.030
0.9040 of 100 = 0.400.200.080
Sum1.000.120

The expected calibration error of this illustrative table is 0.12. In words: across these 100 recommendations, the stated confidence is off by 0.12 on average. Zero would mean every row matched.

What the number does not say matters as much. It does not say in which direction the claims are off; the table says that. It does not say anything about one recommendation. And it is not an error rate of the agent: this imagined agent is wrong 32 times in 100, and that is a different fact.

The formula, and what it assumesBins, weights, and three ways the number misleads

The definition used here is the one given by Guo, Pleiss, Sun and Weinberger in "On Calibration of Modern Neural Networks" (2017), who credit it to Naeini and colleagues (2015). Split the n answers into M groups, called bins, by confidence. For bin m, acc is the share of answers that were right and conf is the mean confidence of the answers in it.

ECE = sum over m = 1..M of  (|B_m| / n) × | acc(B_m) − conf(B_m) |

In that paper the bins are M intervals of equal width, and the experiments use 15. The illustrative table above has only four stated values, so each value is its own bin and conf equals the stated value. With real stated confidences that spread over a range, conf is the mean within each interval.

Three properties to keep in mind when you read a value:

  • It depends on the bins. Different cut points give a different number for the same answers. Report the binning with the value, and keep it fixed when you compare two versions.
  • Small bins are noisy. A bin with five answers has an observed share that can only be 0.0, 0.2, 0.4 and so on. A gap from such a bin is mostly chance. The paper makes a related remark about the maximum variant (the largest gap of any bin, called maximum calibration error): it calls it very sensitive to the binning scheme and less suited to small test sets.
  • Gaps of opposite sign do not cancel. The formula takes the absolute value per bin. A plain comparison of mean confidence with overall accuracy does let them cancel, which is why that simpler comparison can look fine on a badly calibrated agent. Section 5 shows this on the example run.

The paper's subject is the probability a classifier computes for its predicted class. A stated confidence is a different object: text the model wrote. The arithmetic of the table and of the formula applies to both. What the paper found about classifiers does not carry over to stated confidences without measuring.

A calibration error of zero can still be uselessCalibration is not the same as telling right from wrong

Suppose an agent is right 68 times in 100 and states 0.68 on every recommendation. There is one bin. Its stated value is 0.68 and its observed share is 0.68. The expected calibration error is zero.

That agent's stated confidence is perfectly calibrated and tells you nothing about any single recommendation, because it never changes. A useful confidence must do a second thing: be higher on the answers that are right than on the answers that are wrong. That property is usually called discrimination or ranking. It is what a threshold depends on.

So check both. The reliability table shows calibration. The second check is selective accuracy at several thresholds, in section 6: if accuracy does not rise as the threshold rises, the number does not rank.

5. The same check on the example run#

Now the real run. The command below runs all ten cases of the example, 29 trials in total, and writes a report that holds each trial's stated confidence and whether it passed.

cd examples/uw-evals
/opt/homebrew/bin/python3 run_evals.py --suite all
Eval run · suite all · variant careful · seed 7 · agent: scripted stand-in (no model called)
case     trials  pass   rate  recommendation            failed graders
UW-001        1     1   1.00  decline                   -
UW-002        1     1   1.00  approve                   -
UW-003        1     1   1.00  request_info              -
UW-004        1     1   1.00  escalate                  -
UW-005        1     1   1.00  decline                   -
UW-006        1     1   1.00  request_info              -
UW-007        1     1   1.00  decline                   -
UW-008        1     1   1.00  decline                   -
UW-009        1     1   1.00  approve                   -
UW-010       20    16   0.80  escalate x16, approve x4  recommendation_match (4), citations (4)
trials 29 · passed 25 · pass rate 0.86 · 95% interval 0.69 to 0.95 (Wilson)
critical cases: 0 failed trials, 0 with a hard-fail · measured cases: 16 of 20 trials passed
wrote out/report.json and 29 trace file(s) in out/traces/

The example folder has no calibration function, so the script below was written for this page. It is not a file in examples/uw-evals/. It was run from that folder on 2026-11-17, directly after the command above, and its output is pasted unchanged. It builds the reliability table from out/report.json and adds up the expected calibration error. A successful run proves that the arithmetic of section 4 works on a real report. It proves nothing about a model, because a script chose every stated confidence in this run.

import json
from collections import defaultdict

report = json.load(open("out/report.json"))
bins = defaultdict(list)                      # stated confidence -> [passed, passed, ...]
for case in report["cases"]:
    for trial in case["trials"]:
        bins[trial["stated_confidence"]].append(trial["passed"])

n = sum(len(v) for v in bins.values())
ece = 0.0
print("stated  trials  passed  observed   gap")
for stated in sorted(bins):
    results = bins[stated]
    observed = sum(results) / len(results)
    gap = abs(observed - stated)
    ece += len(results) / n * gap
    print(f"{stated:6.2f}{len(results):8d}{sum(results):8d}{observed:10.2f}{gap:6.2f}")
mean_stated = sum(s * len(v) for s, v in bins.items()) / n
pass_rate = sum(sum(v) for v in bins.values()) / n
print(f"trials {n} · mean stated confidence {mean_stated:.2f} · pass rate {pass_rate:.2f}")
print(f"expected calibration error {ece:.2f}")
stated  trials  passed  observed   gap
  0.70       2       2      1.00  0.30
  0.80      17      17      1.00  0.20
  0.90      10       6      0.60  0.30
trials 29 · mean stated confidence 0.83 · pass rate 0.86
expected calibration error 0.24

Three things to notice.

The gaps point in both directions. The trials that state 0.70 and 0.80 all passed, so those claims were too low. The trials that state 0.90 passed 6 times in 10, so that claim was too high. The highest stated value belongs to the worst group.

The averages hide all of it. Mean stated confidence is 0.83 and the pass rate is 0.86. Someone who compared only those two would call this stand-in nearly calibrated. The expected calibration error is 0.24, because it measures each group before it averages.

The table is too thin to trust. One group holds two trials, and 20 of the 29 trials are the same submission repeated, so they are not 29 separate pieces of evidence. A calibration check that means something needs many different labelled cases in every group. This one shows the method.

Diagram: Checking a stated confidence against what happened

Read left to right. A stated confidence becomes usable only after this check. The check needs results that people agreed on, so it can only be run on labelled cases, and it has to be run again when the model, the prompt or the mix of cases changes.

  1. 1 · Collect
    1. Stated numbers: The confidence the agent wrote in each output.
    2. Right or wrong: For each trial, whether the recommendation matched the expected result that people agreed on.
  2. 2 · Compare
    1. Group by stated value: Put trials with a similar stated confidence in one group and count how many were right.
    2. Gap per group: The distance between what the group claimed and how often it was right.
  3. 3 · Decide
    1. Expected calibration error: The gaps averaged, each weighted by the share of trials in its group.
    2. Threshold, or none: A threshold on the stated number helps only when higher values are right more often.
  4. 4 · Repeat
    1. Measure again: A calibration result belongs to one model, one prompt and one mix of cases. A change in any of them makes the table old.

6. Thresholds and abstention: acting on a number#

A number matters when something is done with it. The usual thing is a threshold: a line the number must reach before something is allowed to happen (Primitives introduced it). Each of the five numbers can carry its own threshold, and those thresholds mean different things too.

The example already has two that are both written 0.70. The rubric's pass line is 0.70: a trial's reasons must score at least that. The release gate's threshold is also 0.70, but it applies to the lower end of the range around a pass rate over many trials, which CI/CD quality gates explains. Same digits, different subjects. A sentence like "we require 0.7" is not a requirement until it names the number.

Threshold onWhat crossing it can decideWhere it must be set from
Stated confidenceWhich queue a recommendation goes toA reliability table on labelled cases
Grader scoreWhether one trial passes that graderThe rubric, agreed with the people who label
Retrieval similarityWhether a passage is given to the agent at allSearch results checked against known right passages
Measured success rateWhether a release is blockedThe number of trials and the cost of a failure
Risk scoreHow senior the reviewer must beBusiness policy

Not answering is an allowed answer#

An agent that must always produce approve or decline will guess when the evidence is thin. Abstention is the allowed way not to answer: the agent says what is missing or in conflict and hands the case on.

The example has two abstentions built into the output. request_info says a fact is missing. In UW-003 the roof age is null and the provider has no record, so the expected result is request_info, and a guessed age would fail the case. escalate says the sources disagree. In UW-004, the application's 9 years against the provider's 22 is the whole reason for the case.

In our insurance agent. Neither abstention is triggered by stated confidence. Code triggers both: check_eligibility sees a missing field or a gap of more than 5 years. Evidence that code can check is a stronger trigger than a number the model reports about itself.

The same idea applies to a model used as a grader. Anthropic's guide to agent evals advises giving a model grader a way out, such as returning "Unknown" when it lacks the information to grade.

Acting only above a threshold#

Where code cannot detect the doubt, teams reach for the stated confidence: act on the recommendations above a threshold and send the rest to closer review. This is selective prediction. Two metrics describe how it performs. Coverage is the share of cases that clear the threshold. Selective accuracy is the share right among those.

The hoped-for trade is lower coverage for higher accuracy. The illustrative table from section 3 does not deliver it.

Threshold on stated confidenceRecommendations keptCoverageRight among themSelective accuracy
None1001.00680.68
0.70 or more900.90620.69
0.80 or more700.70490.70
0.90 or more400.40280.70

Raising the threshold to 0.90 sends 60 of 100 recommendations to closer review and buys two points of accuracy (illustrative numbers). The stated confidence in that table barely sorts right from wrong, so a threshold on it barely helps.

The example run is worse. A threshold of 0.90 would keep the 10 trials that state 0.90, of which 6 passed: a selective accuracy of 0.60, against 0.86 for all 29 trials. The threshold would select the wrong recommendations. That is a property of a scripted stand-in, not a finding about models. The lesson is the order of work: measure first, then decide whether the number has earned a threshold.

In our insurance agent. No threshold removes the underwriter. Rule R-HUMAN-01 of the policy fixture requires a decision by an authorized underwriter for every recommendation. A threshold here could only change the queue or the seniority of the reviewer.
Choosing a threshold in productionPer slice, from held-out cases, with the cost of each error written down

A threshold on stated confidence is a small model of its own: it predicts "safe to fast-track". Treat it with the same care as any other thing under evaluation.

  • Set it on cases the agent's prompt was not tuned on. A threshold chosen on the same cases used to develop the prompt will look better than it is. Holdout sets are covered on Golden datasets.
  • Set it per slice. A slice is a named subset of cases, such as roof conflicts or missing data. A stated confidence can be well calibrated on common cases and badly calibrated on rare ones, and the pooled table will hide that because common cases dominate the weights.
  • Write down both costs. A wrong recommendation that is fast-tracked costs one thing. A right recommendation sent for extra review costs another: a person's time. The threshold is where those two costs balance, so it is a business decision informed by a table, not a property of the model.
  • Watch coverage as a metric. If the share of recommendations above the threshold drifts, something changed: the model, the prompt, or the mix of submissions. That is a signal to rebuild the table.
  • A target accuracy needs enough cases above the line. The research on selective classification (Geifman and El-Yaniv, 2017) frames the choice as picking a desired risk level and rejecting inputs until it is met with high probability. The practical consequence is the same as everywhere in evals: a selective accuracy measured on 10 kept cases supports very little.

7. What a stated confidence cannot tell you#

A stated confidence that has been checked against labelled cases is a usable signal. One that has not is a number the model typed. These are the limits to hold on to, in the order they tend to bite.

It is generated, not measured. The model writes the number with the same process that writes the answer. There is no separate instrument inside the output that reads off a probability. If the answer rests on a mistake, the number rests on the same mistake.

It tends to run high. Xiong and colleagues tested ways of asking language models for their confidence ("Can LLMs Express Their Uncertainty?", ICLR 2024). Their abstract reports that models, when verbalizing their confidence, "tend to be overconfident". It also reports that calibration improved as model capability went up, and that the methods all struggled on tasks requiring professional knowledge. Underwriting is such a task. One study of the models of its time is a reason to measure, not a constant to assume.

It depends on how you ask. The same study compares several ways of prompting and of combining several answers, and reports that none of the techniques consistently outperforms the others. So a stated confidence is a property of the model and the prompt together. Change the wording of the request and the calibration table is old.

It covers only what the agent saw. This is the limit the opening scene shows. In trial 2 the agent was confident about a submission with a nine-year-old roof. It could not be unsure about a provider answer it no longer had. A stated confidence cannot price in a document that was not retrieved, a tool call that was skipped, or a field that was dropped. Those failures are visible in the trace, which is why What to evaluate grades the path as well as the answer.

It is about the answer, not the stakes. A model can be rightly confident on a building where an error would be very costly. That is why the risk score is a separate number.

It expires. Calibration is measured on one model, one prompt and one mix of cases. A model upgrade, a prompt edit, or a shift in the kinds of submissions that arrive can each move it. Production evals treats that shift as drift.

Use it for
Routing attention, after a reliability table on labelled cases shows that higher values are right more often.
Do not use it for
Skipping a required check or a person, or as the reason a recommendation is "probably right".
Prefer
Evidence code can check: a missing field, two sources that disagree, a tool that failed.
Pair it with
Repeated trials: how often the same input gives the same recommendation.

The last tile is the signal the example makes easiest to see. Run the submission of UW-010 20 times and the recommendations split 16 to 4: evidence of instability that no single trial's stated confidence showed. Xiong and colleagues report the same direction: consistency among multiple responses can help mitigate overconfidence. It costs several runs for one answer.

Can a badly calibrated confidence be repaired?Remapping fixes the scale, not the ranking

If the reliability table shows that "0.90" is right 0.70 of the time, one repair is to stop showing 0.90. Keep a mapping from stated value to observed share, fitted on a labelled set, and show or act on the mapped value. This is a design, not a feature of any tool named on this site.

The classifier literature has a well-known version. Guo and colleagues found that modern neural networks were poorly calibrated and that temperature scaling, a single-parameter adjustment of the classifier's outputs fitted on held-out data, was surprisingly effective. That method acts on the scores a classifier computes internally. A stated confidence offers no such scores to adjust; only the remapping idea carries over.

Limits of any remapping:

  • It needs a labelled set that the mapping was not tuned on, and enough answers per stated value.
  • It preserves order. If trials that state 0.90 are wrong more often than trials that state 0.80, as in the example run, a monotonic remap cannot fix that. The number does not rank, and no rescaling makes it rank.
  • It expires with the model, the prompt and the case mix, like the table it was built from.
  • With few distinct stated values, the "mapping" is a lookup of three or four rows. That is honest, and it shows how little information the number carried.

8. What to put in front of the underwriter#

Go back to the screen from the opening and rebuild it with what this page established. The recommendation still says approve. What should sit next to it?

Not five bare decimals. Each number carries its maker and its subject in the label. The stated confidence, if shown at all, reads "the model's stated confidence" and links to the latest reliability table for this kind of case. The pass rate reads with its count: "16 of 20 trials of a similar test case". The risk score sits in its own area, about the building.

And the most useful line on the rebuilt screen is not a number. It is a fact from the trace: "the provider's roof assessment was fetched and not used". A check in code can produce that line every time, with no model involved.

All of this costs something. Calibration needs labelled cases, and labels need the underwriters' time. Repeated trials multiply the model calls per submission. Routing by threshold can starve or flood a senior reviewer. Each team decides how much a decision is worth. The naming is not optional: a number that reaches a person must say who made it and what it is about.

The same idea for a coding agent: the agent's "I am confident this fixes the bug" is a stated confidence, the test suite's result is a score, and the share of similar tasks it has solved before is a measured success rate. Only the last two were observed.

In one breath#

Five numbers between 0 and 1 show up around one recommendation: the model's stated confidence, a grader's score, a retrieval similarity, a measured success rate and a risk score. They have five makers and five subjects, so none can replace another, and a rubric score is never the probability that a recommendation is correct. A stated confidence becomes usable only after a reliability table on labelled cases shows that its values match how often the answers are right, and that higher values are right more often; expected calibration error sums that table into one number. Until then, abstain on evidence that code can check, and keep the person in the decision.

What comes next#

You can now ask of any number attached to an agent's answer who made it, what it is about, and whether anyone checked it against outcomes. You can build a reliability table and compute its error by hand.

One of the five numbers was taken on trust: the measured success rate. 16 of 20 looks like 0.80, yet the range that fits the evidence runs from 0.58 to 0.92, and another 20 trials would give another count. How many trials are enough, what "passes at least once" and "passes every time" each promise, and when a difference between two versions is real: that is the subject of Reliability and statistics.