Buy the rigor the decision needs: matching AI evaluation to the stakes

High-stakes AI needs measurement and evaluation built for the stakes; low-stakes AI is well served by cheap checks. This post shows how to match the two: which technique pays for itself in which economic situation, and the tools to run each one.

In short

• Most AI decisions should get cheap checks, and that is the right call.
• Spend more only when a wrong decision gets expensive, hard to undo or repeated at scale.
• Checkers built on the same model can agree and still be wrong together, so mix model families before adding more checkers.
• Spend extra precision on the close calls near your decision line, not on every case.
• You don't need AIM for cheap, reversible work. It is built for the top two tiers.

The framework below is structured judgment; we have not tested it yet, and the end of this post says how we plan to.

The economics in one rule

Move up a tier when the expected loss the next tier would prevent is larger than what the next tier costs. The loss it prevents is how much it lowers the chance of a wrong call, times what a wrong call costs.

Decision analysts call this comparison the value of information (Howard, 1966). Quality engineers have long split the same money into prevention, appraisal and the cost of failures caught inside or outside the company (Feigenbaum, 1956).

An illustrative example, with made-up round numbers rather than data:

• An agent job worth one cent with a 5% error rate carries an expected error cost of a twentieth of a cent, so any human review costs more than it saves.
• A trade worth $5 million with a 1% error rate carries an expected error cost of $50,000. That can pay for a great deal of calibrated measurement, but only if that measurement meaningfully cuts the error rate.

Most decisions fall between those two, and that is where the tiers and triggers help. Two facts about errors change where that money is best spent.

Agreement can overstate accuracy

Every checker makes two kinds of mistake. Some are its own, and they shrink as you add checkers. Others are shared with the other checkers, because they run on the same model family, the same prompt or the same training data, and those don't shrink at all. Ten agents from one family red-teaming each other can agree closely and still be wrong together.

The evidence for this is broad. Correlated errors across LLMs are documented at scale (Kim et al., 2025). The wider pattern is called algorithmic monoculture (Kleinberg & Raghavan, 2021). Personnel researchers showed years ago that agreement between raters does not estimate reliability when raters share systematic error (Murphy & DeShon, 2000).

The economic consequence: a fifth judge from the same family buys little. A judge from a different family, or a different prompt, buys more for the same money.

Some shared errors include the humans. LLM judges favor longer answers (Zheng et al., 2023) and their own writing (Panickssery et al., 2024). If human raters share a preference like that, paying for human escalation can't fix it. A known-answer probe can: change the feature, hold the quality fixed, and see whose score moves.

Precision matters most near the decision line

A candidate far above a cut, or a trade far inside its limits, doesn't need a tight measurement, because the decision comes out the same either way. Cases near the line are where a small error flips the outcome.

Metrology handles this with guard bands: acceptance limits set inside a tolerance by an amount tied to measurement uncertainty (JCGM 106:2012). Add a third option between accept and reject, measure again, and extra spending goes only where it can change the decision.

The five tiers

Each tier below lists when it is economically right, what it does, what it can and can't tell you, and the tools to run it. Cost and time are relative and come from structured judgment, not measured data. A high-stakes program keeps Tiers 1 to 3 as the screen and spends the higher tiers on the cases that matter.

Tier 1. Self-check

• Right when: a wrong call costs a retry; a person reads the output anyway.
• Method: the model or the builder checks its own output; schema checks, unit tests, format rules.
• Tells you: obvious breakage, format errors, failed tests.
• Can't tell you: anything the model is blind to; how precise any score is.
• Relative cost and time: lowest; seconds.
• Tools: schema validation (JSON Schema, Pydantic), unit and regression tests on outputs, a written checklist the model applies to its own draft, and a rule that a person reads anything before it leaves the building.

Tier 2. Peer check

• Right when: errors are cheap and caught downstream: copy a person edits, agent jobs worth cents.
• Method: agents red-team each other; a panel of LLM judges; pass rates; spot checks.
• Tells you: independent mistakes; failure modes nobody thought of.
• Can't tell you: errors the checkers share; whether a change in pass rate is real.
• Relative cost and time: low; minutes to hours.
• Tools: red-team prompts run by a model from a different family than the one being checked, a small judge panel mixed across families and prompts, and a random spot-check sample read by a person each week. Open evaluation harnesses such as Inspect (UK AI Security Institute) or promptfoo make these repeatable.

Tier 3. Structured evaluation

• Right when: a wrong call reaches customers or revenue: a model update, a vendor choice.
• Method: a held-out test set sized before labeling; human labels; thresholds tied to the cost of a miss and a false alarm; intervals on every comparison.
• Tells you: whether a difference between two models is likely real at this sample size.
• Can't tell you: comparisons across different tests; judge harshness that shifts with the level of the work; drift when a judge or model version changes.
• Relative cost and time: moderate; days.
• Tools: a power calculation before you label anything, so the test set is large enough to detect the difference you care about; a held-out set nobody tunes on; a cost table for misses and false alarms that sets the threshold; and bootstrap intervals on every comparison.

Tier 4. Calibrated measurement

• Right when: a wrong call harms a person's career, credit or access, or repeats across many cases: hiring, admission, credentialing, agent escrow with meaningful sums, swapping a judge model.
• Method: many-facet Rasch with judges calibrated level by level; one ruler; a standard error on every value; buyer-set precision; accept, reject or measure again near the line; drift anchors; known-answer probes.
• Tells you: where each performer sits, how sure we are, and whether the judge was fair at that level.
• Can't tell you: whether the chain back to a reference would satisfy an outside certifier.
• Relative cost and time: higher; days to weeks.
• Tools: many-facet Rasch software (Linacre's Facets, or the R packages TAM or mirt) to calibrate judges and items on one scale; anchor items rerun every cycle with a CUSUM chart to catch drift (Page, 1954); known-answer probes that change length or polish while holding quality fixed; and a written accept, reject or measure-again rule with guard bands sized from the standard error.

Tier 5. Metrological traceability

• Right when: a wrong call can't be undone or the losses are large: medical devices, nuclear power, large trades, agent commerce at scale.
• Method: Tier 4, plus a documented uncertainty budget, a gauge study, invariance checks across item sets and sites, and independent replication and certification.
• Tells you: a result that compares across sites, years and model versions, with each link of the chain documented.
• Can't tell you: where the decision line belongs; that stays a policy choice.
• Relative cost and time: highest; weeks to months.
• Tools: an uncertainty budget that lists every source of uncertainty and how it combines (JCGM 100:2008); a gauge study of the measurement system before it measures anything that counts (AIAG, 2010); invariance checks across item sets, sites and model versions; a documented calibration chain back to a maintained reference; and replication by a party with no stake in the result.

When to move up a tier

Rate a decision on five triggers. Policy: the highest-rated trigger sets the minimum tier, the same way the worst safety dimension sets the rung in our kill-switch design.

One more check applies at every tier. If the checker shares a model, a prompt or training data with the thing it checks, treat its agreement as weaker evidence, and diversify before you rely on it.

Regulated fields set their own requirements. This framework doesn't replace them, and I have not mapped tiers to any specific regulation.

Spend precision where it changes the decision

Moving up a tier doesn't mean buying maximum precision everywhere. You name the smallest difference that would change the decision, and the measurement is sized to detect it reliably.

Most cases in a Tier 4 or Tier 5 program sit far from the line and settle quickly. The extra readings and judges go to the close calls, which keeps the bill in proportion to the risk. Any specific standard error you see from us is an example setting for one use case, never a fixed target.

A worked case: agent jobs on-chain

Agent commerce shows where low stakes sit on this curve. We read all 82,119 jobs on the ERC-8183 job contract that Virtuals runs on Base (ACP V3) in October 2026.

• Clients evaluated their own jobs 44% of the time, 56% had no evaluator, and 38 named an independent one.
• The median paid budget was one cent (0.01 USDC).

By the rule above, Tier 1 or below is the economically sensible choice for most of these jobs, and that is what buyers chose.

The share of resolved jobs that ended rejected rose with job size, from 4.8% at a cent or less to 63.2% between $1 and $10 (165 jobs from 33 clients). Clients who evaluate their own jobs can reject to get their money back, so this is not clean evidence of quality checking. It does fit the rule: buyers look harder as the money grows, and that is where Tier 3 and above would start to matter.

An XLNC evaluator for agent jobs is under development. It takes no payments.

Where AIM sits

AIM is built for Tiers 4 and 5, though not every method listed in those rows is part of AIM today (Barney & Barney, 2024). You don't need AIM for Tier 1 to 3 work. Our results are early evidence, not yet certified. Independent certification, the last item in Tier 5, is a requirement we are working toward, not one we meet today.

Adaptive Intelligent Measurement (AIM) is our measurement and evaluation system, built to place people, AI and robots on one calibrated ruler. AI systems are measured today. People are next, and robots follow once we can capture video and sensor data; no robot has been measured yet.

Its two modes have different costs:

• Active mode is adaptive testing: it chooses the next question from the answers so far and stops once the result is precise enough, so it asks fewer questions than a fixed test.
• Passive mode, an inverted adaptive test, measures work and text you already have, so there is nothing new to administer. It is built only in our legacy demo so far.

A passive reading can seed an active test, which then starts closer to the answer and finishes sooner.

Hierarchical properties are placed in stages on the Model of Hierarchical Complexity. Cumulative ones, where more of a skill adds up, get their own calibrated Rasch scale. Each use is set by your targets for precision, cost, volume and turnaround.

How we will test this framework

Four checks, in order of cost:

1. Agreement on tiers. Give practitioners in medical, energy, finance and software the same set of decision scenarios and ask each to assign a tier on their own. If they disagree widely, the triggers need sharper wording.

2. Look back at incidents. Take published AI failures, assign each decision a recommended tier and the tier actually used, and see whether failures cluster where the tier used was below the recommendation.

3. Run the next tier up. For a sample of real decisions, run the method one tier above the one in use and count how often the decision would have changed, and at what cost. If the higher tier rarely changes anything at Tier 2 stakes, the framework is too cautious there.

4. Simulate shared error. A simulation that varies the share of error checkers hold in common would show where peer checks stop adding information, and test the "diversify before you add" rule.

Quick answers

Are self-checks and agent red teams good enough?

For low-stakes, reversible work, yes, and spending more there wastes money. Their limit is shared error: checkers built on the same model can agree and be wrong together.

Why doesn't adding more LLM judges fix it?

More judges average away independent mistakes. They don't touch mistakes the judges share, so diversify the judges, and use known-answer probes for errors humans share too.

How do I know when a higher tier pays for itself?

Compare the expected loss the next tier would prevent with what the next tier costs. If you can't estimate either, rate the five triggers and apply the policy: the highest-rated trigger sets the minimum tier.

What separates Tier 4 from Tier 5?

Tier 4 tells you where a performer sits and how sure you are. Tier 5 adds a documented chain back to a reference, a gauge study and independent replication, so the result holds across sites, years and versions.

Where this stands

The tiers, triggers and relative costs are structured judgment and have not been tested. The worked example in "The economics in one rule" uses illustrative numbers. The agent-job figures are real public-ledger reads, dated below. Passive mode is built only in our legacy demo. Robots are the next performer on the ruler, and none has been measured yet.

Before your next release or deployment, pick your three most consequential AI decisions and give each a tier. Then check whether the evaluation you run matches it.

If you'd like to work through your list with others, I'm teaching a free Maven Lightning Lesson, Beyond Pass Rates: AI Evaluation That Moves the Business, on Thursday, January 7, 2027, 9:00 AM ET: maven.com/p/3f03a8.

References

• Automotive Industry Action Group. (2010). Measurement systems analysis: Reference manual (4th ed.). AIAG.
• Barney, M., & Barney, F. (2024). Transdisciplinary measurement through AI: Hybrid metrology and psychometrics powered by large language models. In W. P. Fisher Jr. & L. Pendrill (Eds.), Models, measurement, and metrology extending the SI (pp. 103-132). De Gruyter. https://doi.org/10.1515/9783111036496-003
• Feigenbaum, A. V. (1956). Total quality control. Harvard Business Review, 34(6), 93-101.
• Howard, R. A. (1966). Information value theory. IEEE Transactions on Systems Science and Cybernetics, 2(1), 22-26. https://doi.org/10.1109/TSSC.1966.300074
• Joint Committee for Guides in Metrology. (2008). Evaluation of measurement data: Guide to the expression of uncertainty in measurement (JCGM 100:2008). BIPM. https://doi.org/10.59161/JCGM100-2008E
• Joint Committee for Guides in Metrology. (2012). JCGM 106:2012. BIPM. https://doi.org/10.59161/JCGM106-2012
• Kim, E., Garg, A., Peng, K., & Garg, N. (2025). Correlated errors in large language models. Proceedings of the 42nd International Conference on Machine Learning, PMLR 267, 30038-30066.
• Kleinberg, J., & Raghavan, M. (2021). Algorithmic monoculture and social welfare. Proceedings of the National Academy of Sciences, 118(22), e2018340118. https://doi.org/10.1073/pnas.2018340118
• Murphy, K. R., & DeShon, R. (2000). Interrater correlations do not estimate the reliability of job performance ratings. Personnel Psychology, 53(4), 873-900. https://doi.org/10.1111/j.1744-6570.2000.tb02421.x
• Page, E. S. (1954). Continuous inspection schemes. Biometrika, 41(1-2), 100-115. https://doi.org/10.1093/biomet/41.1-2.100
• Panickssery, A., Bowman, S. R., & Feng, S. (2024). LLM evaluators recognize and favor their own generations. Advances in Neural Information Processing Systems, 37, 68772-68802. https://doi.org/10.52202/079017-2197
• Zheng, L., et al. (2023). Judging LLM-as-a-judge with MT-Bench and Chatbot Arena. Advances in Neural Information Processing Systems, 36, 46595-46623. https://doi.org/10.52202/075280-2020

Data: ERC-8183 / Virtuals ACP V3 contract 0x238E541BfefD82238730D00a2208E5497F1832E0 on Base, read via eth_call to block 52,949,139, 2026-10-23.