Silent Failure Detection

Detect when LLM agents fail silently - appearing to work while producing incorrect results.

Overview

• Detecting when agents skip expected tool calls
• Identifying gibberish or degraded output quality
• Monitoring for infinite loops and token consumption spikes
• Setting up statistical baselines for anomaly detection
• Alerting on non-error failures (service up but logic broken)

Quick Reference

Tool Skipping Detection

from langfuse import Langfuse

def check_tool_usage(trace_id: str, expected_tools: list[str]) -> dict:
    """
    Detect when agent skips expected tool calls.

    Based on Akamai's middleware bug: agents stopped using tools
    when hidden middleware injected unexpected instructions.
    """
    langfuse = Langfuse()
    trace = langfuse.fetch_trace(trace_id)

    # Extract tool calls from trace
    actual_tools = [
        span.name for span in trace.observations
        if span.type == "tool"
    ]

    missing_tools = set(expected_tools) - set(actual_tools)

    if missing_tools:
        return {
            "alert": True,
            "type": "tool_skipping",
            "missing": list(missing_tools),
            "message": f"Agent skipped expected tools: {missing_tools}"
        }
    return {"alert": False}

Gibberish/Quality Detection

from langfuse.decorators import observe, langfuse_context

@observe(name="quality_check")
async def detect_gibberish(response: str) -> dict:
    """
    Detect low-quality or gibberish outputs using LLM-as-judge.
    """
    # Quick heuristics first
    if len(response) < 10:
        return {"alert": True, "type": "too_short"}

    if len(set(response.split())) / len(response.split()) < 0.3:
        return {"alert": True, "type": "repetitive"}

    # LLM-as-judge for quality
    judge_prompt = f"""
    Rate this response quality (0-1):
    - 0: Gibberish, nonsensical, or completely wrong
    - 0.5: Partially correct but missing key information
    - 1: High quality, accurate, complete

    Response: {response[:1000]}

    Score (just the number):
    """

    score = await llm.generate(judge_prompt)
    score_value = float(score.strip())

    langfuse_context.score(name="quality_check", value=score_value)

    if score_value < 0.5:
        return {"alert": True, "type": "low_quality", "score": score_value}
    return {"alert": False, "score": score_value}

Loop Detection

class LoopDetector:
    """Detect infinite loops and token consumption spikes."""

    def __init__(
        self,
        max_iterations: int = 10,
        token_spike_multiplier: float = 3.0,
        baseline_tokens: int = 2000
    ):
        self.max_iterations = max_iterations
        self.token_spike_multiplier = token_spike_multiplier
        self.baseline_tokens = baseline_tokens
        self.iteration_count = 0
        self.total_tokens = 0

    def check(self, tokens_used: int) -> dict:
        self.iteration_count += 1
        self.total_tokens += tokens_used

        # Check iteration count
        if self.iteration_count > self.max_iterations:
            return {
                "alert": True,
                "type": "max_iterations",
                "iterations": self.iteration_count,
                "message": f"Agent exceeded {self.max_iterations} iterations"
            }

        # Check token spike
        expected_tokens = self.baseline_tokens * self.iteration_count
        if self.total_tokens > expected_tokens * self.token_spike_multiplier:
            return {
                "alert": True,
                "type": "token_spike",
                "tokens": self.total_tokens,
                "expected": expected_tokens,
                "message": f"Token consumption spike: {self.total_tokens} vs expected {expected_tokens}"
            }

        return {"alert": False}

Statistical Baseline Anomaly Detection

import numpy as np

class BaselineAnomalyDetector:
    """Detect anomalies vs statistical baseline."""

    def __init__(self, window_size: int = 100, z_threshold: float = 3.0):
        self.window_size = window_size
        self.z_threshold = z_threshold
        self.history = []

    def add_observation(self, value: float) -> dict:
        self.history.append(value)
        if len(self.history) > self.window_size:
            self.history = self.history[-self.window_size:]

        if len(self.history) < 10:
            return {"alert": False, "reason": "insufficient_data"}

        mean = np.mean(self.history[:-1])
        std = np.std(self.history[:-1])

        if std == 0:
            return {"alert": False}

        z_score = abs(value - mean) / std

        if z_score > self.z_threshold:
            return {
                "alert": True,
                "type": "statistical_anomaly",
                "z_score": z_score,
                "value": value,
                "mean": mean,
                "std": std
            }
        return {"alert": False, "z_score": z_score}

Key Decisions

Decision	Recommendation
Detection priority	Tool skipping > Gibberish > Loops > Anomalies
Quality check	LLM-as-judge with heuristic pre-filter
Loop threshold	10 iterations or 3x baseline tokens
Anomaly threshold	Z-score > 3.0 (99.7% confidence)
Alert strategy	Alert on silent failure, not just errors

Silent Failure Types

Type	Detection Method	Alert Priority
Tool Skipping	Expected vs actual tool calls	Critical
Gibberish Output	LLM-as-judge + heuristics	High
Infinite Loop	Iteration count + token spike	Critical
Quality Degradation	Score < baseline	Medium
Latency Spike	p99 > threshold	Medium

Anti-Patterns

# ❌ NEVER assume success if no error raised
result = await agent.run()
# Missing: quality check, tool usage check

# ❌ NEVER ignore abnormal patterns
if len(response) > 0:  # "Not empty" is not "correct"
    return response

# ✅ ALWAYS validate tool usage
expected_tools = ["search", "calculate"]
tool_check = check_tool_usage(trace_id, expected_tools)
if tool_check["alert"]:
    alert(tool_check)

# ✅ ALWAYS check output quality
quality = await detect_gibberish(response)
if quality["alert"]:
    fallback_to_human_review()

Detailed Documentation

Resource	Description
references/tool-skipping-detection.md	Agent tool usage monitoring patterns
references/gibberish-detection.md	Output quality scoring, LLM-as-judge
references/loop-detection.md	Token spikes, retry patterns, circuit breakers
references/baseline-comparison.md	Statistical anomaly detection
checklists/silent-failure-setup-checklist.md	Implementation checklist

Related Skills

• langfuse-observability - Trace analysis for tool usage
• quality-gates - Quality threshold enforcement
• observability-monitoring - General alerting patterns
• advanced-guardrails - LLM output safety checks

Capability Details

tool-skipping

Keywords: tool skip, missing tool, agent tools, expected behavior Solves:

• Detect when agents don't use expected tools
• Monitor agent behavior consistency
• Debug middleware interference (Akamai scenario)

gibberish-detection

Keywords: gibberish, nonsense, quality check, llm judge Solves:

• Detect low-quality LLM outputs
• Identify repetitive or nonsensical responses
• Quality gate for production outputs

loop-detection

Keywords: infinite loop, retry loop, token spike, stuck agent Solves:

• Detect agents stuck in loops
• Monitor token consumption anomalies
• Prevent runaway costs

baseline-anomaly

Keywords: anomaly, baseline, z-score, statistical, deviation Solves:

• Detect deviations from normal behavior
• Statistical anomaly detection
• Early warning for silent failures

latency-monitoring

Keywords: latency, slow, p99, degraded, performance Solves:

• Detect degraded but non-failing service
• Monitor response time anomalies
• SLO compliance for LLM calls