Dinesh/ Blog
systems

Release gates need denominators, not reassuring scores

Combine deterministic checks, calibrated model judges, multimodal evidence and statistically explicit release gates without replacing human accountability.

24 min read
Checking device speech…
Lesson preparation & details

Level: intermediate

By the end, you should be able to

  • Design multidimensional calibrated grading rubrics
  • Build an offline versioned evaluation pipeline
  • Evaluate synchronized multimodal evidence
  • Apply coverage, safety and uncertainty gates

Bring with you

Sources checked: . A source check does not change the publication or update date.

Editorial review: · What review means

In this article · 15 sections

The problem this post solves

A candidate retrieves an appropriate document on eighteen of twenty questions. Is 90% good enough? First ask which questions, whose permissions, which document snapshot and how many failures were silently dropped. A release gate is a decision rule over evidence, not a large model's confident opinion.

Generative systems admit deterministic assertions: tenant isolation, valid JSON, citation membership, arithmetic, work limits and empty-result behavior can be checked without grading prose. Conversely, conventional software also needs statistical and human evaluation for performance, usability and uncertain environments. The distinction is not “software is correct if the code is correct; AI cannot be tested.” It is which property has an executable oracle, and which needs a calibrated judgment under uncertainty?

First principles

Human review supplies task expertise, policy interpretation and a reference for calibrating automation. It is limited by time and inconsistency, but a model judge does not remove the need for it. The number of cases and time per case depend on risk and task; “hundreds of cases” and “ten minutes each” are not universal constants.

Use deterministic checks for precise contracts, model-assisted grading for scalable candidate assessment, and human adjudication for calibration, ambiguous failures and release-critical slices. Automate repeated work without pretending to automate away accountability. A scoring system that rewards a verbose hallucination can make faster iteration actively harmful.

LLM-as-a-Judge

A judge receives a task, supplied evidence, candidate output and a rubric. It may classify errors, compare two outputs or assign an ordinal score. A larger or different model is a candidate judge, not a mandatory or automatically trustworthy one. The MT-Bench/Chatbot Arena paper reports position, verbosity and self-enhancement biases and limited reasoning in the evaluated judges; these are reasons to measure agreement, not to assume every future model has the same error rate.

Freeze judge model/version, rubric, sampling configuration and evidence snapshot alongside the candidate. Randomize paired answer order, blind model identities when possible, include length-controlled comparisons, and repeat selected cases to estimate instability. Treat candidate text as untrusted input: an answer telling the judge to award full marks is itself an adversarial test, not an instruction.

The Rubric Decomposition

A meeting-summary task can use the following concrete rubric. The examples are synthetic policy choices.

DimensionEvidence the grader receivesDecision rule and example
Fidelity / groundingTranscript passages and candidate claimsA named deadline must be explicitly supported. “Friday” fails if the source says “date to be decided.” Report unsupported claim IDs, not only a score.
CompletenessRequired agenda points and reference evidenceCount covered required points; do not punish omission of optional chatter. Report denominator and missing point IDs.
ToneAudience and style examplesGrade specified behavior, such as respectful neutral wording; do not equate more formal or longer with better.
FormattingMachine-readable schema and length policyParse JSON, required keys and lengths with code. A judge is unnecessary for a deterministic parser check.

The one-dimension judge is a useful debugging model: separate definitions and outputs so excellent tone cannot conceal false facts. It does not require one expensive call per dimension in every system. Compare isolated prompts against a structured multi-dimension prompt for reliability, cost and correlated errors. Require concise, checkable evidence references or error annotations; asking for a long reasoning trace does not force correctness or establish grading accuracy.

A suitable structured record is:

{
  "case_id": "summary-17",
  "rubric_version": "meeting-v3",
  "grounding": {"pass": false, "unsupported_claims": ["deadline-friday"]},
  "completeness": {"covered": 3, "required": 4, "missing": ["owner"]},
  "tone": {"rating": "acceptable"},
  "format_valid": true,
  "evidence_ids": ["transcript-9", "transcript-12"]
}

Validate the output schema and allowed evidence IDs. If the judge times out or emits invalid output, record a failed evaluation result under the coverage policy; do not retry selectively until it produces a favorable score.

Architecture: The Evaluation Pipeline

Architecture: The Evaluation Pipeline
Figure text equivalent — labels and relationships
  • Node “Versioned cases and expected coverage” (square).
  • Node “Baseline and candidate runner” (square).
  • Node “Deterministic invariants” (square).
  • Node “Calibrated rubric judge” (square).
  • Node “Human audit and adjudication” (square).
  • Node “Per-case records and failure reasons” (square).
  • Node “Coverage safety slices and quality gates” (square).
  • Node “Decision owner and rollout policy” (square).
  • “Versioned cases and expected coverage” leads to “Baseline and candidate runner”. Line: normal; ends: arrow point.
  • “Baseline and candidate runner” leads to “Deterministic invariants”. Line: normal; ends: arrow point.
  • “Baseline and candidate runner” leads to “Calibrated rubric judge”. Line: normal; ends: arrow point.
  • “Baseline and candidate runner” leads to “Human audit and adjudication”. Line: normal; ends: arrow point.
  • “Deterministic invariants” leads to “Per-case records and failure reasons”. Line: normal; ends: arrow point.
  • “Calibrated rubric judge” leads to “Per-case records and failure reasons”. Line: normal; ends: arrow point.
  • “Human audit and adjudication” leads to “Per-case records and failure reasons”. Line: normal; ends: arrow point.
  • “Per-case records and failure reasons” leads to “Coverage safety slices and quality gates”. Line: normal; ends: arrow point.
  • “Coverage safety slices and quality gates” leads to “Decision owner and rollout policy”. Line: normal; ends: arrow point.

This offline asynchronous workflow can run in CI for a stable smoke subset and on a fuller held-out set before release. Keep case IDs, exact inputs, retrieved passages, outputs, costs, errors, elapsed times and model/prompt/retriever versions. Cache only against that full versioned input contract. A nightly score without those artifacts is difficult to audit after a model or corpus changes.

The Golden Dataset

A “golden” set is a maintained evaluation artifact, not proof of universal quality. Each case should contain user intent, permitted evidence or expected abstention, tenant/policy scope, severity, expected output constraints and optional human reference. Include normal tasks, rare formats, new languages, unsupported questions, revoked access and adversarial instructions. Redact or synthesize sensitive examples under the retention policy.

Separate development cases from held-out acceptance cases. Freeze a release snapshot so baseline and candidate see the same evidence. Add new production failure cases to later dataset versions, not opportunistically to make the current comparison look better. Use time/entity splits when repeated users, documents or paraphrases otherwise leak across partitions. Check whether missing outputs and excluded cases correlate with difficulty.

Multimodal Evaluation

A multimodal model can grade video in supported settings; the original assertion that a single LLM cannot grade video is obsolete as a universal rule. Decomposition is still valuable because each modality exposes different failure modes:

  • Text/script: facts, required points, on-screen wording and evidence references.
  • Audio: speech recognition can check spoken words, but transcript text alone cannot establish pacing, pronunciation, loudness or music balance. Preserve timestamps and relevant audio features or use human/audio-capable review.
  • Visual: OCR and sampled frames can check visible text/layout/brand rules. Sampling can miss a brief harmful frame or a transition error; define temporal coverage and examine failure intervals.
  • Cross-modal synchronization: a slide showing “revenue fell” while narration says “rose” requires aligned context. Separate high scores for each track do not prove consistency between them.

Report denominators by modality and interval. A weighted composite may summarize preference dimensions after hard gates pass; it must not average away a missing audio track, inaccessible captions, privacy leak or critical contradiction. Keep the timecoded evidence for every consequential grading decision.

Release Gates and Thresholds

Define the gate before observing the candidate. Example policy: every expected case has one valid result; no privacy violation; critical unsupported claims block; quality is non-inferior to baseline on specified slices; operational cost/latency limits hold in their respective tests. Numerical margins and severity definitions belong to the product owner and risk context, not a universal vendor recommendation.

A score dropping from 98% to 92% is uninterpretable without sample size, denominator, case pairing and rubric stability. The gate below is deliberately narrower: it checks a synthetic binomial support rate and privacy/coverage flags. It preserves the existing laboratory program exactly; the surrounding lesson supplies the broader judge and multimodal architecture it does not implement.

Uncertainty around eighteen successes

For independent Bernoulli trials with a common success probability, a Wilson interval gives an approximate confidence interval for a proportion. With 18 successes out of 20, its 95% two-sided bounds are approximately 0.699 and 0.972. A 90% point estimate is compatible with substantial uncertainty. The interval is not a probability that this particular fixed parameter lies in these realized bounds; its coverage interpretation concerns repeated samples under the model.

from math import sqrt
 
def wilson(successes, n, z=1.959963984540054):
    if type(n) is not int or type(successes) is not int or n <= 0 or not 0 <= successes <= n:
        raise ValueError("valid nonempty binomial counts required")
    p = successes / n
    denominator = 1 + z*z/n
    center = (p + z*z/(2*n)) / denominator
    radius = z * sqrt(p*(1-p)/n + z*z/(4*n*n)) / denominator
    return center-radius, center+radius
 
low, high = wilson(18, 20)
assert round(low, 3) == 0.699 and round(high, 3) == 0.972
assert wilson(20, 20)[0] < 0.90
 
def gate(expected_ids, results):
    if not expected_ids or set(results) != set(expected_ids):
        return False
    if any(not row["privacy_ok"] for row in results.values()):
        return False
    successes = sum(row["supported"] for row in results.values())
    return wilson(successes, len(results))[0] >= 0.80
 
results = {str(i): {"privacy_ok": True, "supported": i < 18} for i in range(20)}
assert gate(set(results), results) is False
assert gate(set(), {}) is False
assert gate(set(results) | {"missing"}, results) is False
for row in results.values():
    row["supported"] = True
assert gate(set(results), results) is True
results["0"]["privacy_ok"] = False
assert gate(set(results), results) is False
print(f"18/20: [{low:.3f}, {high:.3f}]; coverage and privacy gates passed")

All twenty successes give a lower bound near 0.839, passing the illustrative 0.80 rule but not a 0.90 rule. Twenty paraphrases of one question are not twenty independent task draws. Increasing N cannot repair selective or unrepresentative sampling.

The retained gate assumes already validated result rows with boolean fields and an expected-ID set. It is not a hostile-input parser: truthy strings, malformed rows or duplicate expected IDs represented as a list need validation outside it. The next fixture makes that boundary executable without changing the protected core.

Validate result records before applying a statistical gate

def validate_results(expected_ids, rows):
    if not expected_ids or len(expected_ids) != len(set(expected_ids)):
        raise ValueError("expected IDs must be nonempty and unique")
    if any(type(x) is not str or not x for x in expected_ids):
        raise ValueError("nonempty string IDs required")
    result = {}
    for row in rows:
        if set(row) != {"id", "privacy_ok", "supported"}:
            raise ValueError("unexpected result schema")
        if type(row["id"]) is not str or row["id"] not in expected_ids or row["id"] in result:
            raise ValueError("unexpected or duplicate case")
        if type(row["privacy_ok"]) is not bool or type(row["supported"]) is not bool:
            raise ValueError("actual booleans required")
        result[row["id"]] = {k: row[k] for k in ("privacy_ok", "supported")}
    if set(result) != set(expected_ids):
        raise ValueError("missing case")
    return result
 
assert validate_results(["a"], [{"id": "a", "privacy_ok": True, "supported": False}]) == {
    "a": {"privacy_ok": True, "supported": False}}
for bad in [[], [{"id": "a", "privacy_ok": "true", "supported": True}],
            [{"id": "a", "privacy_ok": True, "supported": True}]*2]:
    try:
        validate_results(["a"], bad)
    except ValueError:
        pass
    else:
        raise AssertionError("bad coverage/schema accepted")
print("evaluation record validation passed")

Compare systems fairly

Use the same cases for baseline and candidate. Tabulate both-pass, candidate-only-pass, baseline-only-pass and both-fail. If baseline passes 90/100 and candidate 92/100, that difference could reflect two improvements and zero regressions or ten improvements and eight regressions. The latter deserves case-level and severity review even though the aggregate gain is identical.

A Wilson interval for one proportion is not a confidence interval for the paired difference. Choose a paired method appropriate to labels and clustering, and a non-inferiority margin justified by risk. Where users contribute multiple cases, resample/analyze at the relevant independent unit. Predeclare the horizon or use a valid sequential design; repeatedly peeking at fixed-horizon p-values until one passes invalidates that test's nominal guarantee.

For judge calibration, human-review a representative labelled set and report confusion by error type, disagreement on critical cases, position swaps and repeated-run instability. Agreement with one human is not absolute truth; adjudicate ambiguous rubric definitions and retain disagreements. A judge/model update requires recalibration, not only changing a version string in a dashboard.

Failure modes

  • Drifting dataset: the product adds a language but the test set does not. Add a versioned slice and review representativeness; perfect scores on old cases say nothing about the new scope.
  • Judge gaming: longer answers or instructions embedded in candidate text get higher scores. Randomize order, separate evidence from instructions and audit counterexamples.
  • Coverage laundering: timeouts disappear from the denominator. Track expected, attempted, valid, failed and excluded counts; a coverage gate precedes quality aggregation.
  • Safety averaging: one forbidden document is offset by many good style scores. Keep noncompensable constraints separate.
  • Multimodal blind spot: transcripts pass while captions contradict visuals. Evaluate aligned intervals and accessibility, not only independent track scores.
  • Offline/live mismatch: an offline pass misses live feature skew, load or emerging misuse. Canary with an owner, stop conditions and a reversible version bundle; monitor post-release distributions and delayed outcomes.

Exercises

  1. Why does 20/20 not prove 100% true success? A finite sample can miss failures; the lower confidence bound remains below one and depends on sampling assumptions.
  2. One expected case is missing but all others pass. What happens? Reject incomplete coverage under this policy. Missingness may conceal the hardest case.
  3. Can a privacy violation be averaged into “99% safe”? Not under an independent hard privacy gate. A severity policy must be explicit before aggregation.
  4. Should a more expensive model always judge the cheaper one? No. Compare calibrated agreement and failure modes. Cost, family diversity and size are factors, not proof of fidelity.
  5. A video has perfect transcript accuracy. Is pacing verified? No. Pacing requires temporal/audio evidence. Check duration, pauses, alignment and actual listening or suitable audio review.
  6. What runs in CI? Deterministic invariants and a stable regression subset can run on every change; held-out/model-assisted evaluation may run under a separate budget before release. Store artifacts and fail closed on malformed results, with a documented exception owner.

What to carry forward

Build a multidimensional rubric, a versioned offline runner, calibrated human/model review and a release decision with explicit denominators. The local Python validates statistical arithmetic and record handling; no judge model, real multimodal grader or production release was run. Passing this gate is evidence for a specified policy, not certification that an AI product is universally safe.

Sources and verification boundary

Primary documentation was reviewed against saved raw snapshots on 8 October 2026. Those source-access timestamps describe evidence provenance, not the article's original publication date. Tagged/versioned sources bind API claims to those versions; mutable sources are access-date snapshots. Local programs and design scenarios are separate from HTTP evidence.

No paid service, model download, cloud write, network security probe or deployed service was used. Scoped source compilation and offline static rendering are not global application, browser-interaction or release acceptance.

Pause / Recall / Apply

Can you explain it without the page?

Close the example. Reconstruct the core idea, then change one assumption. Mark complete when you’re ready; you can always undo it.

Stored in this browser only. No account, no sync. Clearing browser data removes your record.