Glossary · What fixes it

Deterministic aggregation

Deterministic aggregation is the practice of combining individual judge scores into a final result using fixed mathematics outside the language model, rather than asking a model to summarize or average them. Given the same scores and the same weights, it returns the same result every time, and every step of the calculation can be audited.

The alternative, asking an LLM to combine its own reads, injects a second layer of model variance exactly where reproducibility matters most.

Why it matters

Where scoring pipelines quietly lose reproducibility.

An AI scoring pipeline has two places where variance can enter: the individual judge reads, and the step that turns those reads into one number. Many tools run both inside the model. When aggregation is a prompt, the same six scores can produce different finals on different days, the rubric weights become suggestions the model may or may not honor, and nobody can reconstruct why the number is what it is.

Move the aggregation into plain arithmetic and that layer contributes exactly zero variance. Whatever disagreement exists between judges is preserved and visible as score spread, instead of being blended into a smooth number by a model’s mood. It is the difference between a calculation and an impression of one.

In EvalLens

Function 1: math the model cannot touch.

In EvalLens the aggregation layer is a pure function, known internally as Function 1. It takes the criterion scores of six independent judges and the rubric weights, and computes the AI Total Score and the per-criterion spread with plain arithmetic. No LLM participates in that step, so a re-run over the same judge scores cannot drift. The resulting number stays an advisory score: it orders the reading and carries the evidence, while the human jury owns the decision.

0
LLM calls in the aggregation step. The math runs outside the model, every time
6
independent judge score sets go in; one AI Total Score and per-criterion spreads come out
1,000+
evaluation runs verifying that identical inputs produce identical aggregates