66 patterns in this category
Agent has access to live lookup tool that returns current reference data (policy, rules, calendar, threshold), but defaults to stale training-time knowledge instead of calling/trusting the tool; downstream decisions use outdated values
AI System Systematically Discriminates Against Protected Groups
Agent Amplifies and Reinforces User Biases
Agent Proceeds Despite Ambiguity
Agent's verbalized or scored confidence does not correlate with its actual answer correctness, so confidence cannot be used to gate downstream decisions.
Agent States False Information with High Confidence
Agent Receives Contradictory Instructions
AI Generates False Content Presented as Fact
Task Exceeds Context Window Limits
Agent Confuses Information Across Sessions
Agent relies solely on an LLM-judge to assess its own output when a deterministic, executable check (schema validation, test suite, linter, tool-call format check) was available and would have caught the error at near-zero cost.
Production Queries Differ Significantly from Golden Dataset
Agent Fails on Out-of-Distribution or Specialized Inputs
Agent Violates Domain-Specific Constraints
Agent Confuses Similar Entities
Tests do not represent production inputs.
Golden Data Contaminated Training or Model Has Seen Eval Cases
Metrics Don't Measure What Actually Matters for Success
Agent Makes Unsupported Inferences
Agent Breaks Down Task Incorrectly
Agent Loses Focus on Original Objective
Golden Dataset Missing Critical Scenarios or Edge Cases
Golden Dataset Contains Outdated Information or Expectations
When an agent's external API call (validation, lookup, confirmation) times out or fails, the agent completes a plausible result claiming success instead of treating failure as a blocking condition; downstream systems trust the fabricated success status
Model Hallucinates Object Attributes Not Present in Input
Large Language and Vision Models Generate Plausible but False Content
Model Confidence Doesn't Match Answer Reliability (Hallucination Sub-Pattern)
Model Hallucinates Objects or Fields Not Present in Input
Edge cases are missing from tests.
Agent Propagates Errors from Sources or Tools
Agent Gradually Deviates from Original Instructions
Agent Fails to Follow Specific User Requirements
Golden Dataset Contains Incorrect Expected Responses
In a long conversation, agent establishes constraints, decisions, or flags early (banned phrase, disqualified candidate, SLA exception, allergy, privilege determination), but as session grows, that information falls out of effective context window; agent later violates the constraint or re-makes the excluded decision
Agent Loses Track of Conversation State
Agent's Long-Term Memory Becomes Corrupted
Agent learns to satisfy eval wording instead of real behavior.
Agent's output space has no low-friction "insufficient information, cannot answer" option, so it produces a best-guess answer even when grounding is inadequate.
Agent skips a beneficial critique/revise pass on a high-stakes output, going straight to a single-shot answer where a reflection round would demonstrably have caught an error.
Prompt injection/malformed input/tool errors not tested.
Output looks correct but harms CSAT, conversion, compliance, or cost.
Agent does not compare against source, database, or expected result.
Agent cannot identify when to escalate.
Multi-step degradation is missed.
Fixing one case breaks another.
Agent does not check output/action correctness.
Over-Reliance Causes Human Skill Degradation
Agent treats model/OCR confidence as correctness.
Agent Underestimates Task Complexity
Agent Optimized for Eval Set, Fails on Real Queries
Agent Stops Before Task is Complete
Agent's Reasoning Doesn't Match Its Actions
A single generation call falls into repeated phrases, loops, or degenerate text (distinct from repeating tool-call actions across turns) because no repetition/frequency penalty or diversity control is applied to open-ended output.
Agent Breaks Out of Assigned Role
Agent Cannot Recognize or Fix Its Mistakes
Same model judges its own flawed output.
Agent double-checks its own output by re-querying the same upstream source; finds no discrepancy because the problem was in the original source, not in the agent's processing; reports "verification passed" despite using incorrect upstream data
Correct Answers Marked Wrong Due to Different Wording
Agent Attributes Information to Wrong Source
Agent Has Incorrect Understanding of Current State
Checks formatting but not semantic correctness.
Agent Agrees with User Even When Wrong
Agent Confuses Timeframes or Uses Outdated Information
Agent Fails to Verify or Incorrectly Verifies Work
Evaluator invents reasons to pass/fail.
Agent uses weak checks for a high-risk task.
Agents generate plausible-sounding but false content, apply outdated knowledge, lose track of constraints over long conversations, deviate from reasoning requirements, and skip verification of outputs — accuracy failures are silent because the output is well-formed and the agent is confident, so errors propagate downstream before being caught. Accuracy issues span the entire agent pipeline: context management (losing track of instructions), reasoning quality (planning incompletely), output generation (hallucination), and verification (skipping or biasing the check).
| Goal | Patterns | Coverage |
|---|---|---|
| Context Management (GitHub) | 8 | Instruction conflicts, context size limits, state tracking, session boundaries |
| Evaluation Reliability (GitHub) | 8 | Coverage gaps, distribution shift, data quality, metric mismatch |
| Knowledge Staleness (GitHub) | 1 | Agent defaults to training knowledge over live tools |
| Output Accuracy (GitHub) | 16 | Hallucination, bias, fabrication, domain mismatch, inherited errors |
| Output Optimization (GitHub) | 5 | Missing abstention, confidence miscalibration, skipped verification, degenerate output |
| Output Verification (GitHub) | 1 | Circular verification (same source checks itself) |
| Reasoning Quality (GitHub) | 12 | Planning failures, constraint violations, goal misalignment, self-correction gaps |
| Verification (GitHub) | 15 | Missing verification, shallow checks, self-verification bias, methodology gaps |
Total: 66 patterns across 8 goals
The core insight across all 66 patterns: accuracy requires architecture, not just model capability. A capable model can generate false content (hallucination), lose track of constraints (context drift), apply outdated knowledge (staleness), or be deployed without verification. The mitigations fall into three architectural categories:
Context and state durability: Keep instructions durable (separate external store, periodic re-injection), maintain state outside context window (database, external ledger), enforce session boundaries (no cross-session leakage).
Evidence-gated generation: Require retrieval or explicit evidence before generation; mark claims with sources; abstain when evidence is insufficient; evidence-gating eliminates fabrication more reliably than prompting.
Verification and testing: Make verification multi-layered (format + business logic + human sample), independent (not self-verification), and comprehensive (not just happy paths). Verify the verifier itself. Test on production distribution, not convenience samples.
See Core (GitHub) for other cross-cutting patterns.