Back to Projects

Agent Eval Studio | Release-Oriented Agent Evaluation

A runnable loop from Golden Set and A/B comparison to bad cases and release gates

Independent Project | Product Design, Evaluation System & AI Coding Aug 2026 – Present Independent Project Runnable Eval Demo · Real-model integration in progress 2026-08-19
TypeScript Node.js HTML JSON OpenAI-compatible
Agent Eval AI Product Evaluation Open Source
Agent Eval Studio evaluation flow from Golden Set to release gate
01

30-second summary

I replaced “this Agent feels better” with a reviewable release decision: freeze samples and scoring criteria, compare baseline and candidate, aggregate bad cases, and evaluate multiple product gates before release.

02

Three key numbers

60
Golden Set samplesReviewable dataset in the repository
10
Task typesDifferent capability and risk scenarios
5
Scoring dimensionsOne rubric for consistent A/B comparison
03

Product flow

  1. 01
    Define the Golden Set

    Freeze tasks, expectations, and risk labels.

  2. 02
    Run A/B

    Execute baseline and candidate on identical samples.

  3. 03
    Score the rubric

    Turn quality dimensions into structured results.

  4. 04
    Aggregate bad cases

    Locate regressions and failure patterns by type.

  5. 05
    Check multiple gates

    Evaluate quality, cost, P95 latency, and safety together.

  6. 06
    Archive evidence

    Produce JSON artifacts and a readable HTML report.

04

Two key decisions

01

Ship a deterministic mock by default instead of requiring a live model

Why this choice
The evaluation framework itself must be reproducible and testable, and reviewers should run it without an API key.
Alternative not chosen
Make a real model API the only execution path
Tradeoff
Current results do not represent live-model quality, but the evaluation and reporting pipeline is stable and reviewable while provider integration continues.
02

Use multiple release gates instead of one average-quality score

Why this choice
An average can hide safety regressions, tail latency, and cost increases that would block a real release.
Alternative not chosen
Release whenever the candidate's average quality rises
Tradeoff
The decision has more parameters and is stricter, but it better reflects product constraints.
05

One bad case

A higher average concealed a high-risk regression

Symptom
The candidate improved on common samples but failed a small set of safety tasks, while the overall average remained positive.
Diagnosis
One aggregate metric diluted critical failures among many routine samples.
Response
Made risk labels, bad-case groups, and the safety gate independent blocking conditions.
Outcome
The report now explains not only which average is higher, but why a version still cannot ship.
06

Result and validation status

Evaluation pipeline verified · Real-model effect unverified

The repository contains runnable commands, automated tests, 60 samples, JSON artifacts, and an HTML report. The current provider is deterministic; OpenAI-compatible configuration does not yet execute live model calls.

07

Evidence links

08

Full retrospective

Project Overview

Agent Eval Studio is an open-source workbench for version comparison and release decisions. It connects evaluation data, scoring rules, run artifacts, and release conditions into one traceable path. Its purpose is not a polished score alone, but an explanation of why a candidate can or cannot ship.

Pain Points & Opportunities

Agent teams can over-rely on curated demos, subjective impressions, or averages. Those methods are hard to reproduce and can hide rare high-risk failures. A quality gain accompanied by worse cost or tail latency may also be unsuitable for release.

Goals & Metrics

The goal was a repeatable A/B baseline with identical data, a shared rubric, structured bad cases, and explicit gates. Reviewers should run the whole loop without an API key, while the absence of a live-model provider remains visible.

User Research

The design follows the essential evidence chain for Agent evaluation: a Golden Set stabilizes input, dimension-level rubrics resist single-score distortion, bad cases explain failure patterns, and multi-objective gates connect evaluation to release constraints.

Solution Design

The data layer stores tasks, expectations, and risk labels. Baseline and candidate receive identical input. Scoring produces five dimensions; analysis groups task types and bad cases; gates jointly check quality, cost, P95 latency, and safety; reporting emits both machine-readable JSON and human-readable HTML.

Execution Plan

I used TypeScript and Node.js to implement the CLI, deterministic provider, dataset loading, scoring aggregation, gates, and report generation, with automated tests for critical logic. OpenAI-compatible configuration remains an extension point, and mock results are explicitly not presented as live-model outcomes.

Results Review

The current version runs all 60 samples end to end, compares two deterministic configurations, and outputs dimension scores, bad cases, a release decision, JSON artifacts, and an HTML report. It validates the evaluation product and engineering path, not an improvement in any real model or prompt.

Iteration Reflection

The core product value of evaluation is not automated scoring; it is reviewable decision evidence. The next step is to add a live provider and human-calibrated examples, then compare automated and human judgments. Until then, marking the validation boundary clearly is more valuable than manufacturing a complete-looking production metric.