Every team shipping an AI agent eventually hits the same wall. The demo works. The pilot works. Then real users break it in ways nobody scripted, and the engineering team discovers that its test suite was measuring the wrong thing entirely.
The instinct is to write more tests. The problem is that agents are not functions. They are probabilistic systems that loop, call tools, hold state, and operate in environments nobody fully controls. A unit test that asserts an exact string will fail on a paraphrase and pass on a confidently wrong answer. Neither outcome tells you whether the agent is safe to ship.
That is the context behind Plurai's positioning, reported by TechCrunch: borrow the playbook that got autonomous vehicles onto public roads. Instead of hand-writing assertions, you construct scenarios, run the agent through them repeatedly, and score behaviour statistically across many trials. It is a genuinely different philosophy from the benchmark-and-dashboard approach most teams default to — and it is only one of four viable options.
This guide compares those options, gives you a criteria table, and recommends a combination by scenario.
Why agent evaluation is a different problem

Figure: Editorial context image from the source page (preview only; rights remain with the publisher) · Credit / further reading: techcrunch.com
Classical software testing rests on determinism. Same input, same output, same pass or fail. Agents break all three assumptions. Sampling temperature, tool latency, retrieved context, and conversation history all shift the output distribution. Two runs of the same prompt can produce one correct answer and one plausible-sounding failure.
The self-driving analogy is useful because it reframes what you are measuring. You do not verify a driving model by asserting that a specific steering angle is correct. You expose it to thousands of kilometres of simulated and recorded driving, and you measure the distribution of outcomes: how often it brakes late, how it behaves in rain, what happens at an ambiguous four-way stop. Coverage and failure rate replace pass/fail.
Applied to agents, that means three questions matter more than any single test: How representative are my scenarios? How many trials did I run before drawing a conclusion? And does the score correlate with what users actually experience?
The four approaches, side by side
1. Static benchmarks and golden datasets
The default. You curate input/output pairs, or run the agent against a public benchmark, and report accuracy. It is cheap, reproducible, and easy to put in CI. Its weakness is coverage: golden sets encode the failures you already imagined, and they go stale the moment the product surface changes. They are excellent regression guards and poor discovery tools.
2. LLM-as-judge rubric scoring
A second model grades the agent's output against a rubric — tone, faithfulness to retrieved sources, task completion. This scales to open-ended outputs where exact matching is meaningless, and it handles paraphrase gracefully. The catch is that judges carry their own biases: they favour verbose answers, they can be talked into agreeing, and they drift when the judge model is upgraded. Treat the judge as an instrument that needs its own calibration against human labels.
3. Simulation and scenario replay
This is the autonomous-driving approach. You build an environment — mocked tools, synthetic users, adversarial inputs, recorded production traces — and run the agent through it many times to measure outcome distributions rather than single outcomes. It is the only method that surfaces multi-step and tool-interaction failures, and the only one that produces statistically meaningful failure rates. It is also the most expensive to build, and its value collapses if the simulated environment drifts from production.
4. Online production evaluation
Shadow mode, canaries, A/B tests, and human review queues. This is the ground truth: real users, real edge cases, real consequences. Signal arrives slowly and sometimes painfully, but nothing else tells you whether your offline score means anything. The trade-off is exposure risk, which is why online evaluation belongs behind guardrails — rate limits, rollback paths, and escalation to a human.
Comparison table
| Criterion | Static benchmarks | LLM-as-judge | Simulation & replay | Online production |
|---|---|---|---|---|
| Setup cost | Low | Low to medium | High | Medium to high |
| Realism | Low | Medium | Medium to high | Highest |
| Edge-case coverage | Low | Medium | High | High but uncontrolled |
| Signal speed | Instant | Minutes | Minutes to hours | Days to weeks |
| Reproducibility | High | Medium | High | Low |
| Measures failure rate | No | Partially | Yes | Yes |
| Main risk | False confidence | Judge bias and drift | Simulation gap | User harm |
| Best for | Regression guards | Open-ended quality | Pre-launch validation | Confirming real impact |

Figure: HEXOPS original illustration inspired by the topic (not a copy of the source article imagery) · Credit / further reading: techcrunch.com
Choosing by scenario
Pre-launch, high blast radius
If the agent touches money, infrastructure, health information, or customer data, simulation and replay should carry most of the weight. Build scenario suites around the failures that would hurt most, run enough trials to get stable failure rates, and set release gates on the distribution rather than on a single passing run. Pair it with a small static suite as a fast regression tripwire, and keep online exposure narrow at first.
Consumer-facing chat, shipping weekly
Velocity dominates here. LLM-as-judge rubrics plus a compact golden set give you fast, cheap feedback on every change, and a canary rollout catches what the rubric missed. Invest in judge calibration — a few hundred human-labelled examples will tell you whether your judge agrees with your users — and revisit the rubric whenever the product surface shifts.
Internal operations automation
Internal agents usually have high volume and moderate blast radius, which makes online evaluation unusually attractive. Shadow mode against real traffic gives you a realistic failure taxonomy before you flip the switch, and human review queues convert user corrections into new scenarios. The pattern that works: shadow, then canary, then promote, feeding everything back into the simulation suite.
Multi-agent and tool-heavy workflows
Single-step evaluation tells you almost nothing when an agent orchestrates five tools and two sub-agents. Simulation is the only affordable way to explore interaction failures — loops, retries that double-charge, handoffs that drop context. Budget for environment engineering as a first-class workstream, not a side project.
The pragmatic stack: layer, don't replace
The comparison is not really a contest. These four approaches answer different questions, and mature teams run all of them at different cadences. Static benchmarks run on every commit. Judge-based scoring runs on every prompt or model change. Simulation runs before release and nightly. Production telemetry runs continuously and feeds back into the scenario library.
The failure mode to avoid is single-method confidence: a green benchmark suite that says nothing about behaviour, or a simulation harness so divorced from production that it validates a system nobody uses. Whichever layer you invest in first, close the loop — every production incident should become a scenario, and every scenario should trace back to a real or plausible user outcome.
Key takeaways
- Agents are probabilistic; single-run pass/fail assertions measure almost nothing useful.
- Simulation and replay is the strongest pre-launch tool for multi-step and tool-heavy agents, but only if the environment tracks production.
- LLM-as-judge scales to open-ended quality and needs its own calibration against human labels.
- Static benchmarks are excellent regression guards and poor discovery tools.
- Online evaluation is the only ground truth — use it behind guardrails and feed results back into offline suites.
- Layer the methods by cadence and by blast radius rather than choosing one.
Next steps
- Write down the three worst plausible failures for your agent and the blast radius of each.
- Audit your current suite: does it measure outcomes or strings?
- Stand up a minimal scenario harness for the highest-risk workflow, with mocked tools and repeated trials.
- Add a judge rubric for open-ended quality and calibrate it against 100–200 human labels.
- Define a release gate expressed as a failure-rate threshold, not a single green run.
- Wire production incidents and user corrections back into the scenario library on a fixed cadence.



