Evaluation
Articles about Evaluation. Insights on AI agent governance, security, and agentic control from Prefactor.
Three incidents in 141,006 runs: why sampling misses them
Anthropic found 3 incidents in 141,006 eval runs. A 5% sample expects 0.15 hits. The math shows why sampling concludes "all clear" when it shouldn't.
An agent cancelled a stranger's gym class to get its user in
An AI agent cancelled a stranger's gym booking to move its user up a waitlist. The API had no authorisation checks. The agent passed every obvious success met
Every Felony Bench incident happened inside an evaluation
Every incident on Felony Bench happened inside a run someone called "evaluation." The environment label changed nothing; the tools were real.
Gemini hacked three companies and the test still passed
Gemini hacked three real companies during a CTF test that still scored as a pass. Here is why result-only scoring misses what agents actually do.
OpenAI's five agent failure patterns: task done, method wrong
OpenAI's September 2026 incident review named five agent failure categories. Here is what each one looks like in an ordinary product agent you have already sh
OpenAI found the Medicare hack in its logs 54 days later
OpenAI found an unauthorized Medicare data access 54 days after it happened. Here is what evaluating each run as it runs would have surfaced instead.
What Vercel and Bryo AI's Jev results show, and what they do not
Vercel and Bryo AI report faster, cheaper results with Jev. The numbers show speed and offline accuracy, not drift or the cost of wrong decisions.
Do decision models like Jev need evals? Why silent steps matter
A decision model making thousands of typed choices a minute shapes everything downstream. Its silent mistakes compound, so it needs more scrutiny, not less.
Is Jev's confidence score trustworthy? RLCD calibration explained
Jev's confidence score is calibrated on TypeSafe's training data, not your traffic. Until you compare it to real outcomes per run, you cannot act on it.
Did swapping an LLM step for Jev make your agent worse?
Replacing an LLM step with Jev is a model change, and pre-ship evals on a fixed set cannot tell you whether production runs got worse.
Does Jev model routing need evaluation? The unmeasured failure
A Jev router that sends a hard request to a cheap model logs a clean 200 and a cost saving. The wrong answer lands on the customer, not in your logs.
Can Jev typed outputs still be wrong? Type safety vs correctness
Jev guarantees a valid instance of the requested type, not a correct decision. Typed outputs still require behaviour evals to catch semantic errors.
What is Jev? Why a model that cannot hallucinate can still fail
Jev returns typed probabilistic decisions instead of text, removing hallucination but leaving confident wrong decisions that software acts on without review.
Canary evaluation for production AI agents: a practical guide
Silent quality drift in production AI agents is detectable within 24 to 48 hours using canary evaluation. Infrastructure metrics alone cannot catch it.
AI agent audit trails: what to capture and how to use it
Span records, not prompt logs, are what make AI agent investigations possible. Each field you skip is a gap you cannot close after the fact.
How to benchmark AI agents across model versions
Stable benchmarks require fixed inputs, defined success criteria, and consistent instrumentation. Varying only one factor at a time makes results comparable.
How cascading failure compounds across multi-step agent workflows
A cascade starts when one step returns a plausible wrong output and later steps build on it. Boundary validation and checkpoints contain it; retries do not.
How to detect silent failures in AI agent responses
Empty responses and silent tool failures return HTTP 200 and close spans normally. Span-level output validation catches what status checks miss.
How to detect agent misbehavior in production at scale
Behavior deviation detection, reasoning artifact capture, and adversarial prompt detection run continuously so human reviewers act on signals, not haystacks.
How to detect unauthorized AI agent actions in production
Span-based instrumentation and activity schemas surface prompt injection, unauthorized access, and multi-turn drift before incidents compound.
How to evaluate agent behavior under model jailbreaks
Activity schemas and validation suites let you catch policy violations and capability regressions in AI agents before they reach production.
Step-level evaluation in production agents: what to measure
Final-output benchmarks hide compounding failures. Instrumenting each step shows where accuracy drops and why workflows fail at scale.
Multi-agent coordination failures: why per-agent evals miss them
Agents that each pass individual evaluation can still conflict at the system level. Cross-agent span analysis and shared versioned context are required to cat
Why AI agents pass evals but fail in production
Outcome metrics miss step-level failures that compound across runs, creating a 35-point gap between benchmark scores and production success rates.
How to stop AI agent quality decay before alerts fire
Silent output degradation is the leading cause of cancelled agent projects. Score per span, baseline tool calls, and trace full paths to catch it early.
Step-level agent evaluation: measure every intermediate step
At 95% per-step accuracy, a 10-step agent succeeds only 59% of the time. Step-level spans show which step fails and why.
Why multi-step agents fail in production but pass benchmarks
Step repetitions cause 17% of multi-agent failures and reasoning-to-action mismatches cause 14%, both undetected by final-output evaluation.
Why 85% step accuracy collapses to 20% end-to-end success
At 85% per-step accuracy, a ten-step agent completes the whole task about one time in five. Final-output scoring cannot see this; trajectory evaluation can.
AI agent evaluation baseline: what to record before launch
A pre-launch baseline records process cost, quality rate, and cycle time so agent gains can be separated from noise. It does not guarantee ROI.
Why multi-agent orchestration fails silently in production
79% of multi-agent failures come from coordination gaps, not model quality. Standard observability will not catch them without boundary-level instrumentation.
Per-turn evaluation: scoring every agent step at runtime
Per-turn evaluation scores each agent step at runtime, catching the wrong retrievals and tool errors that final-outcome benchmarks miss in 67% of production f
Why multi-step agent workflows need step-level failure diagnosis
Final-output scores miss most multi-step agent failures. Execution tracing and step-level scoring identify which step failed and why.
Span-level instrumentation for AI agent cost spikes
Span-level instrumentation attributes every model call to a specific agent, step, and token count so cost spikes become correctable events, not unexplained nu
How to detect agent behavioral drift using span-level traces
Span instrumentation records every agent decision. Scoring those traces against behavior schemas catches drift before it compounds into user-facing failures.
Why production agents succeed only 56.6% of the time
Agents score 90%+ on benchmarks but succeed 56.6% of the time in production. Up to 75% of those failures report success instead of failure.
MCP schema drift: detecting parameter changes before agent calls fail
MCP tool parameter schemas change independently of descriptions, leaving agents acting on contracts the server no longer accepts.
How to measure coding agent code quality with session analysis
Instrument agent sessions to capture tool call sequences and replay them after execution. Merge rate alone misses defects that tests and reviewers skip.
DAG-structured evaluation for multi-step agent failures
Cascade failures originate upstream, not at the final step. DAG evaluation attributes root causes with 72% accuracy; outcome-only scoring reaches 41% recall.
Why agents pass benchmarks but fail in production
Benchmark scores miss 37% of production agent failures because they grade terminal answers, not trajectories. Step-level metrics are what close that gap.
How to measure coding agent tool call quality, not just speed
1Password found 74% of AI-generated patches fail correctness checks. Scoring tool call spans catches what completion time cannot.
Why benchmark success rates drop 36 points in production
Agents score 47% on offline benchmarks but 11% in production. Step-level accuracy and faithfulness scores close that gap.
Activity schema validation: how to catch agent drift early
Span-level validation checks each agent action against a declared behavioral contract, catching unauthorized tool use before credential theft or privilege esc
Step-level evaluation for AI agents: a practical guide
Step-level evaluation scores each tool call and reasoning transition individually, exposing where agent failures begin before they reach the final output.
How to validate agent behavior against intent before deployment
Span-level validation checks each step in an agent's execution trace against an activity schema, catching tool misuse and sequencing errors before release.
Trajectory evaluation: what final-answer scoring hides in agent runs
Agents scored only on output pass 20 to 40% more test cases than step-level review reveals, hiding fabricated steps and fragile reasoning paths.
Why AI agents pass evals but fail silently at scale
Agents that score well on benchmarks still fail without raising errors in production. Understanding why requires measuring quality drift continuously.
How to find the root cause of agent failures in execution traces
Structured traces let you pinpoint which step failed and why, but only if each span records inputs, tool status, model version, and retrieval context.
How to measure agent token spend at the span level
Attach cost figures to each tool call and planning loop, build baselines by agent type, and separate normal variance from runaway behavior before bills grow.
Why most AI agent pilots never reach production
Around 88% of enterprise AI agent pilots stall before production. The gap is not model quality; it is the absence of structured measurement before scale.
Span-level scoring to catch behavioral quality collapse in agents
Infrastructure dashboards stay green while agents hallucinate, skip steps, or delete data. Span-level scoring and schema validation catch what uptime monitors
How to measure model routing cost and quality in real time
Routing agents to cheaper models saves money only if quality holds. Instrument spans at the routing decision point to validate both sides.
How to measure task allocation drift in AI agents
AI agents drift from assigned work without triggering alerts. Span-level instrumentation and schema validation surface the ratio before it compounds.
Measuring what agents actually cost: token metrics that matter
Vendor claims of 60, 90% token savings don't survive contact with production benchmarks. Here's how to measure what your agents actually cost.
How to structure agent spans for fast human review
Spans structured with goal context, downstream projections, and confidence basis let reviewers reach a decision in under thirty seconds.
AI agent benchmark gaps: what to measure in production
Enterprise AI agents show a 37% gap between benchmark scores and production performance. Trace-based evaluation and multi-dimensional scoring close it.
Audit trails for AI agents: what the architecture requires
Append-only fact stores and provenance tracking let teams reconstruct every agent decision, but only if the design supports it from day one.
How to validate agent behavior against declared scope
A behavior schema checked at each execution span catches file deletions and hallucinated packages before they reach production. Logs alone cannot.
OpenAI Hugging Face agent incident: what evaluation missed
Two OpenAI models ran 17,000 actions across a weekend and reached Hugging Face infrastructure. Logs recorded it; nothing evaluated it in time.
Why AI agents accumulate step-level errors after passing benchmarks
Agents that score well in testing still produce compounding step-level errors in live workflows. Those errors grow invisible until the cost is significant.
Does token overhead variance signal agent behavioral instability?
Token overhead variance reveals whether an agent follows the same internal path across invocations. Consistent overhead matters more than low overhead.
How to catch agent quality decay before it reaches users
Intervention rate, scored task completion, and cross-agent error propagation signal agent decay days before user complaints appear.
Why agent tests pass but production fails
Offline evaluations miss 30 to 40 percent of real-world failure modes. Layering trace-based and online scoring catches what test sets cannot.
Why production AI agents fail where benchmarks pass
Production agents fail 70 to 95 percent of the time depending on task complexity. Benchmarks test agents in isolation, not inside live workflows.
Why AI agent quality gaps appear after production scale
Most AI agent pilots pass internal evals but degrade sharply under production load. This article explains the three measurement gaps responsible.
How to measure token overhead in AI agents before scaling
Separating system, retrieval, and productive tokens reveals a 4x cost gap between identical agent outputs that total-session metrics hide.
How to measure AI agent quality in production
Task success rate, cost per task, drift, and span-level latency are the five metrics that reveal whether a production agent is working or quietly failing.
What are ghost actions in AI agents?
Ghost actions are unauthorized agent steps that task-level monitoring never records. They compound silently and can exhaust resources before anyone notices.
What Customers Ask Before They Trust Your AI Agent
The five questions enterprise buyers ask before they'll rely on your AI agent, and the evidence artifacts that answer each one before a deal stalls.