Case-Based Reasoning Systems: Learning from Past Decisions

Case-based reasoning (CBR) is an AI methodology in which a system solves new problems by retrieving and adapting solutions from a structured library of previously encountered cases. Unlike rule-based or model-based approaches, CBR derives its inferential power directly from experiential precedent rather than from explicitly encoded domain axioms. The methodology has active deployments across medical diagnosis, legal argumentation, engineering fault detection, and financial credit assessment, making it one of the most operationally diverse paradigms within the broader landscape of reasoning systems.

• Definition and scope
• Core mechanics or structure
• Causal relationships or drivers
• Classification boundaries
• Tradeoffs and tensions
• Common misconceptions
• Checklist or steps (non-advisory)
• Reference table or matrix

Definition and scope

Case-based reasoning is formally defined within the AI literature as a problem-solving paradigm that uses specific past experiences — encoded as cases — to understand, solve, critique, and explain new problems. The foundational theoretical framework was articulated by Roger Schank at Yale University in the early 1980s through his work on dynamic memory and script-based cognition, and was subsequently operationalized by Janet Kolodner, whose 1993 monograph Case-Based Reasoning (Morgan Kaufmann) remains a primary technical reference for the field.

A case in CBR terminology is a structured data unit containing at minimum: (1) a problem description, (2) a solution, and (3) an outcome evaluation. Extended case representations also encode contextual metadata, confidence scores, and failure conditions. The case library — sometimes called a case base — is the indexed repository from which retrieval operates.

The scope of CBR spans both offline systems, which rely on static historical case libraries, and online systems, which continuously ingest new cases as operational feedback. Within types of reasoning systems, CBR occupies a distinct position because its knowledge is implicit in stored experience rather than explicitly declared in rules or ontological axioms.

Core mechanics or structure

The standard CBR cycle, as described in the DARPA-funded research program that produced early CBR toolkits and codified in Aamodt and Plaza's 1994 paper "Case-Based Reasoning: Foundational Issues, Methodological Variations, and System Approaches" (AI Communications, Vol. 7, No. 1), consists of four discrete phases known as the 4R cycle:

1. Retrieve — The system identifies the most similar past case(s) to the new problem using a similarity metric. Retrieval algorithms include nearest-neighbor, k-d tree indexing, and learned embedding similarity. The choice of similarity function is the primary architectural decision in CBR design.

2. Reuse — The retrieved solution is adapted, either directly (verbatim reuse) or through adaptation rules that modify the prior solution to fit the new problem's specific parameters. Null adaptation — using a prior solution unchanged — is valid when similarity exceeds a defined threshold.

3. Revise — The proposed solution is evaluated, typically by domain expert feedback or automated outcome testing. Revisions correct solution elements that do not transfer cleanly from the source case.

4. Retain — Successfully resolved cases are encoded and stored in the case library, expanding its coverage. Retention policies govern which cases are added, which are superseded, and how duplicates are handled.

Similarity computation in Retrieve is mathematically formalized as a weighted distance function across feature vectors. If a case is represented by n features, the local similarity between two cases is commonly calculated as a weighted sum: sim(C1, C2) = Σ w_i · sim_i(f1_i, f2_i), where w_i is the importance weight of feature i. Weights are domain-assigned or learned via gradient descent in hybrid CBR-ML architectures.

For practitioners examining how it works in production systems, the Retain phase is operationally where case-base quality degrades fastest: uncritical retention accumulates redundant or contradictory cases, increasing retrieval noise over time.

Causal relationships or drivers

The inferential power of CBR rests on a single core assumption: similar problems have similar solutions. This assumption — termed the similarity hypothesis — holds in domains where underlying causal mechanisms are stable and where variation between problem instances is structured and measurable rather than discontinuous.

Three primary factors drive CBR performance:

Case library coverage. A library with fewer than 500 cases in a complex domain typically produces low retrieval confidence because the nearest-neighbor match is often distant in feature space. Coverage gaps produce forced adaptations that amplify error.

Feature engineering quality. CBR systems are sensitive to feature representation in a way that distinguishes them from deep learning approaches. If the features indexed in a case do not causally relate to the outcome, similarity scores become unreliable regardless of retrieval algorithm quality. NIST's AI Risk Management Framework (NIST AI RMF 1.0) identifies feature validity as a core data quality concern applicable to experience-based AI systems.

Adaptation mechanism strength. Domains where solutions are compositional — assembled from discrete elements — support rule-driven adaptation. Domains where solutions are holistic or emergent resist systematic adaptation, constraining CBR to near-verbatim reuse and limiting generalization.

Causal reasoning systems address some of these limitations by encoding causal structure explicitly, whereas CBR leaves causal relationships implicit within the case distribution.

Classification boundaries

CBR is distinguished from related paradigms along three structural axes:

CBR vs. rule-based reasoning: Rule-based reasoning systems encode domain knowledge as explicit IF-THEN constructs. CBR encodes no explicit rules; knowledge is distributed across cases. CBR tolerates incomplete domain theories; rule-based systems fail when the rule set has gaps.

CBR vs. model-based reasoning: Model-based reasoning systems derive solutions from structural or functional models of the domain (e.g., circuit schematics). CBR requires no domain model; it is purely data-driven. Model-based systems generalize better to truly novel problems; CBR generalizes poorly outside the case distribution.

CBR vs. instance-based machine learning: k-Nearest Neighbor (kNN) classification is mathematically a degenerate form of CBR in which cases have no solution structure beyond a class label and no adaptation step exists. Full CBR systems are distinguished by structured case representations, explicit adaptation, and active retention policies.

CBR vs. analogical reasoning: Analogical reasoning systems operate on structural relational mappings between source and target domains. CBR operates on feature-level similarity within a single domain. The two paradigms converge in cross-domain CBR, which is an active research area but remains rare in production deployments.

Tradeoffs and tensions

Interpretability vs. scale. CBR is inherently interpretable: the system can cite the retrieved precedent case as justification for its recommendation. This property supports compliance with explainability requirements, including those referenced in the EU AI Act's transparency obligations for high-risk AI systems (EU AI Act, Regulation (EU) 2024/1689, Articles 13–14). However, as case libraries scale past 100,000 cases, retrieval latency and maintenance complexity grow substantially, and the interpretability advantage erodes when the most similar case is still dissimilar in critical features.

Coverage completeness vs. redundancy. Adding every new case maximizes coverage but degrades retrieval precision through redundancy accumulation. Selective retention strategies — such as competence-preserving deletion — improve retrieval efficiency but risk eliminating cases that cover rare but critical problem types.

Adaptation fidelity vs. brittleness. Rich adaptation rules allow CBR to handle cases distant from any precedent, but every adaptation rule is itself a form of encoded domain knowledge that can be wrong. Systems with heavy adaptation logic exhibit a failure mode in which the adapted solution diverges from the retrieved case's validated outcome, creating an accountability gap.

Domain specificity vs. generality. CBR performs best in stable, well-bounded domains. Attempts to deploy a single CBR system across multiple dissimilar domains require domain-specific similarity functions and case structures, effectively creating parallel case libraries with shared infrastructure — a design that hybrid reasoning systems address through modular architecture.

Explainability in reasoning systems covers the broader regulatory and technical landscape within which CBR's auditability properties are evaluated.

Common misconceptions

Misconception: CBR is equivalent to a database lookup. Database retrieval returns exact matches against explicit query keys. CBR retrieval returns approximate matches using multi-dimensional weighted similarity across continuous feature spaces. The distinction is not semantic; it is architectural — CBR systems have a similarity model, databases do not.

Misconception: Larger case libraries always improve performance. Case library quality dominates quantity. A library of 2,000 high-quality, well-indexed cases with validated outcomes typically outperforms a library of 50,000 cases with inconsistent feature encoding and unvalidated outcomes. The competence of a case library — defined as the proportion of problem space it covers with confident retrievals — is the operative quality metric, not raw size.

Misconception: CBR does not require domain expertise. Feature selection, similarity weight assignment, adaptation rule design, and retention policy definition all require substantive domain knowledge. CBR externalizes knowledge from explicit rules but does not eliminate the need for domain expertise; it relocates that expertise into case structure and retrieval configuration.

Misconception: CBR cannot handle novel problems. CBR handles novelty through adaptation. The constraint is that adaptation quality degrades as the distance between the new problem and the nearest case increases. Beyond a defined dissimilarity threshold, CBR systems should escalate to human review rather than produce low-confidence adapted solutions — a design pattern addressed in human-in-the-loop reasoning systems.

Checklist or steps (non-advisory)

Phase sequence for case library construction and CBR system deployment:

• [ ] Domain scoping — Boundaries of the problem space defined; out-of-scope problem types identified and documented
• [ ] Case structure design — Feature set specified; each feature mapped to data source and encoding format
• [ ] Similarity function specification — Local similarity functions defined per feature type (nominal, ordinal, continuous); feature importance weights assigned or learning mechanism selected
• [ ] Initial case library population — Historical cases collected, cleaned, and encoded; minimum viable coverage threshold established
• [ ] Retrieval algorithm selection — Nearest-neighbor, k-d tree, or embedding-based retrieval selected based on case volume and latency requirements
• [ ] Adaptation rule development — Adaptation logic specified for known feature-variation patterns; null-adaptation threshold defined
• [ ] Revise mechanism configuration — Outcome evaluation protocol defined; feedback loop from domain experts or automated testing established
• [ ] Retention policy documentation — Criteria for case addition, replacement, and deletion codified; competence preservation strategy selected
• [ ] Similarity threshold validation — Retrieval confidence calibrated against held-out cases; minimum acceptable similarity score established
• [ ] Failure escalation protocol — Sub-threshold retrieval outcomes routed to human review; escalation criteria documented
• [ ] Audit trail configuration — Each retrieval, adaptation, and retention event logged with case identifiers and similarity scores for auditability of reasoning systems
• [ ] Performance baseline measurement — Accuracy, coverage, and retrieval latency benchmarked prior to production deployment

Reference table or matrix

CBR Variant Comparison Matrix

CBR Performance Factors Summary

Key dimensions and scopes of reasoning systems provides complementary classification frameworks for positioning CBR within the full taxonomy of AI reasoning architectures.