AIToday
Large Language ModelsAI Coding AssistantsOpen-Source AIHacker NewsPublished: Aug 22, 2026, 01:02 JST3 min read

Muteval: mutation testing tool measures if your LLM evals actually catch bugs

Muteval: mutation testing tool measures if your LLM evals actually catch bugs

Key takeaway

  • Muteval applies mutation testing—a software engineering technique—to LLM eval suites. It degrades your system and reruns evals to measure coverage gaps.

  • Scores range from 0% (no evals) to 100% (complete coverage) and come with 95% confidence intervals.

  • The tool integrates with promptfoo, deepeval, and RAGAS, and works with any OpenAI-compatible model.

3 Key Points

  1. What happened

    Muteval is an open-source tool that deliberately degrades an LLM system (prompt, context, tools, or model) and reruns your eval suite against each degraded version to measure a mutation score — the percentage of injected regressions your evals caught. It works with any OpenAI-compatible endpoint (Groq, Gemini, Ollama, local servers) and integrates with existing suites from promptfoo, deepeval, and RAGAS via adapters.

  2. Why it matters

    Regression tools like promptfoo and deepeval catch when your system gets worse, but they don't measure whether your evals are good enough to catch regressions in the first place. Muteval fills that gap — it surfaces which degradations your evals missed (called "survivors"), ranked by severity and paired with suggested fixes. A mutation score of 33% means only 2 out of 6 injected regressions were caught.

  3. What to watch

    Muteval can run in CI with `--fail-under 75` to gate PRs if eval coverage drops, supports caching and parallel evaluation to reduce API costs, and includes a separate probe audit (`muteval probe`) that checks judge reliability, discrimination, and statistical adequacy. The tool is early and open to contributions, especially new mutation operators and adapters.

Ask the AI about this article →

Context & Analysis

Mutation testing is an established practice in software engineering: deliberately introduce bugs (mutations) into code, rerun your test suite, and measure how many bugs the tests catch. Muteval brings this discipline to LLM eval suites, addressing a structural blind spot: passing evals do not guarantee the evals themselves are comprehensive. The tool deliberatedly degrades the system under test across 18 operators — weakening modal language ("ONLY" → "preferably"), deleting sentences, dropping retrieved context documents, corrupting tool outputs, or downgrading the model — and reruns your existing checks against each variant. A mutant is "killed" if your evals catch the degradation; a "survivor" means your evals missed it, flagging a potential coverage gap. The body reports a real example: a support-bot eval with a 33% mutation score (95% CI 10–70%) where the suite missed two regressions — one HIGH-severity (failure to check that answers are grounded in context) and one medium-severity (a weakened modal constraint). Each survivor is paired with a suggested eval (`checks.grounded("context")`) to close the gap. The tool integrates with existing frameworks (promptfoo, deepeval, RAGAS, custom functions, deployed endpoints) and includes a confidence interval calculation and severity ranking to avoid misleading scores. A separate probe audit (`muteval probe`) checks judge reliability, discrimination, and statistical adequacy — treating the eval-quality assessment as a report card rather than a single composite score.

FAQ

What does a mutation score actually tell me?
A mutation score is the percentage of deliberately injected regressions your evals caught. If your score is 33%, your evals caught 2 out of 6 degraded versions. Muteval surfaces the ones your evals missed (survivors) so you can decide which gaps matter and what eval to add.
Can I use muteval with my existing eval suite?
Yes. If you already use promptfoo, deepeval, or RAGAS, you can point muteval at your existing config and it will reuse your metrics and assertions. Muteval also works with a custom function or deployed endpoint via --target or --endpoint.
How much does it cost to run?
You can cap API and judge calls with --max-calls to control spend. Muteval also memoizes results with --cache, so identical re-runs make zero model calls. Parallel evaluation with --concurrency 8 speeds up runs without extra cost per mutant.

Get the latest Large Language Models news every morning

For example, today's edition would include:

  • Nvidia revives Rubin CPX chip with major redesignYahoo Finance AI · 1h ago
  • AI advice followed by 79%, but well-being unchangedITmedia AI+ · 4h ago
  • Enterprises face agent governance gapSiliconANGLE AI · 7h ago

AI-summarized, only the topics you pick — one digest a day via Email, Slack, or Discord.

Free · takes 30 seconds · unsubscribe anytimeWhat is AIToday? →

Ask AI

Ask AI anything about this article. Q&As are published on this page for other readers too.

Related Articles

Next articleYouTube creators face backlash for unpaid Higgsfield AI promotion