LLM-as-judge has become the dominant pattern for evaluating language model outputs. Tools like Promptfoo, Braintrust, and LangSmith all converge on the same architecture: send your prompt to your model, then use another model to score the result. The approach works, but it has a structural problem that nobody talks about enough: the judge model is evaluating with the same limitations and biases as the model being evaluated.

A new open source tool takes a different approach. Instead of relying on a single LLM to judge outputs, it runs two independent quality signals that do not share failure modes. The first signal checks technical correctness against known ground truth where it exists. The second signal measures something more like user-experience quality, using a lightweight model rather than a frontier model. The theory is that a small model that knows what good looks like can catch obvious failures without being fooled by the same patterns that fool a frontier model.

Why LLM-as-Judge Has a Reliability Problem

The standard LLM judge approach is vulnerable in specific ways. A frontier model grading outputs from a comparable frontier model will often give inflated scores because both models share similar text patterns. The judge knows what good output looks like in the same way the evaluated model knows what good output looks like, which means it cannot reliably catch the subtle failures that distinguish a good model from a great one.

There is also a problem of calibration. When you ask a model to rate an output on a scale of 1 to 10, the model is applying internal criteria that may not match the criteria you actually care about. The scores are relative to what the model has seen as good outputs in training, not to your specific use case. This makes cross-model comparisons unreliable unless you have carefully controlled for the judge's training distribution.

The dual-signal approach addresses these issues by not using a language model for one of the signals. When ground truth is available, the tool checks against that directly. When ground truth is not available, it uses a lightweight classifier that was trained specifically to catch the failure modes that current LLMs exhibit. The classifier is not a language model, which means it cannot be distracted by stylistic similarities between the output and the judge's own writing style.

What the Tool Actually Does

The tool runs evaluations in two phases. The first phase is automated and fast: it runs your test cases through the model under evaluation, then runs the outputs through both quality signals. This produces a structured report with specific failure categories and confidence scores for each category. The second phase is human review, guided by the automated report. Instead of having a human reviewer evaluate every output, the tool identifies the outputs most likely to have problems and presents those for human review first.

This two-phase approach reduces the cost of evaluation significantly. Human review is the most expensive part of LLM evaluation, and it does not scale linearly with model quality. When a model is already good, most of the outputs do not need human review. The tool's job is to find the specific outputs that do need it, which makes human review focused and efficient rather than exhaustive and expensive.

The Open Source Angle

The fact that this is an open source tool matters for a specific reason: evaluation methodology is something that is hard to trust without auditing. If a proprietary tool tells you that your model is performing well, you have to take that on faith unless the vendor lets you audit their methodology. An open source tool lets you audit both the methodology and the implementation. You can see exactly how the quality signals work, what training data was used for the classifier, and how the calibration was done.

This is particularly important for teams that have compliance requirements or that are using LLMs in regulated industries. Being able to demonstrate that your evaluation methodology is sound matters for audit purposes, and open source makes that demonstration possible in a way that proprietary tools do not.

Limitations of the Approach

The tool is not claiming to replace LLM-as-judge for all use cases. There are evaluation scenarios where ground truth does not exist and where the lightweight classifier does not have enough signal to be useful. In those cases, you still need a frontier model judge, and the tool acknowledges that explicitly. The value is in identifying the cases where LLM-as-judge is reliable and the cases where it is not, which lets you use the right evaluation method for each output type.

The classifier approach also requires training data that represents the specific failure modes of the models you are evaluating. This means the tool is most effective for teams that have been running LLMs long enough to have collected examples of failures. For teams starting fresh, the tool is less immediately useful because the classifier has nothing to learn from yet. That gap is filled by the ground truth checking for cases where that applies, but creative and open-ended tasks still need a different evaluation strategy.

The other limitation is that the tool currently focuses on text outputs. Multimodal outputs, code, and structured data formats each have their own evaluation requirements that the tool does not yet address. This is a reasonable scope for a first release, but it means the tool is most useful for text-heavy applications like chatbots, content generation, and summarization tasks.

What This Means for Teams Evaluating LLMs

The practical value of this tool is in reducing the cost and noise of LLM evaluation. Most teams that are serious about model quality are running some form of automated evaluation, and most of those teams are using LLM-as-judge because it is the most accessible option. The problem is that accessible does not mean reliable, and the inflated scores from self-serving judges can lead teams to ship models that perform worse than they think.

The dual-signal approach is not a complete solution to this problem. But it is a meaningful improvement over single-signal evaluation, and making it open source means teams can adapt it to their specific contexts rather than relying on a vendor's judgment about what matters. That flexibility is the main reason to pay attention to this project if you are working on LLM evaluation seriously.

Sources

For more insights on AI tooling and evaluation methodology, visit XerAds Blog.