🤖 machine learning

CRAFT: Forgetting-Aware Intervention-Based Adaptation for Continual Learning

CRAFT is a continual learning framework for large language models that mitigates catastrophic forgetting by learning low-rank interventions on hidden representations through a unified three-stage process of task routing, KL-divergence-based fine-tuning, and intervention merging, thereby outperforming strong LoRA-based approaches across multiple benchmarks.

Original authors: Md Anwar Hossen, Fatema Siddika, Juan Pablo Munoz, Tanya Roosta, Ali Jannesari

Published 2026-05-08

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Md Anwar Hossen, Fatema Siddika, Juan Pablo Munoz, Tanya Roosta, Ali Jannesari

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a brilliant, highly trained librarian (the Large Language Model) who knows a lot about history, science, and cooking. You want to teach this librarian new skills every day: today it's coding, tomorrow it's summarizing legal documents, and the next day it's writing poetry.

The problem with traditional teaching methods is that to learn something new, the librarian has to rewrite their own brain. Every time they learn a new skill, they accidentally erase or scramble the old memories. This is called "catastrophic forgetting." If they learn to code, they might forget how to write poetry.

CRAFT is a new way to teach this librarian that solves this problem without ever rewriting their brain. Here is how it works, using simple analogies:

1. The "Sticky Notes" Instead of Rewriting the Brain

Instead of forcing the librarian to change their permanent memory (the model's weights), CRAFT gives them a stack of sticky notes (interventions).

The Brain: The librarian's original knowledge stays frozen and untouched. It never changes.
The Sticky Notes: When a new task comes in, CRAFT writes a tiny, low-rank "instruction" on a sticky note and sticks it onto the librarian's current thought process.
The Result: The librarian can do the new task perfectly using the note, but their original brain remains exactly as it was. No old memories are erased because the brain itself wasn't touched.

2. The "Smart Sorter" (Routing)

You can't just give the librarian a random sticky note for every single task; that would be chaotic. CRAFT uses a Smart Sorter to organize these notes.

The Warm-up: When a new task arrives (e.g., "Summarize a meeting"), CRAFT briefly tries it out to see what kind of "vibe" or output it produces.
The Match: It compares this vibe to the existing groups of sticky notes it already has.
- If the new task feels like "Financial News," it gets grouped with the existing "Finance" sticky notes.
- If it feels totally different, like "Writing Python Code," it gets its own new group.
No Extra Brain: Crucially, this sorter doesn't need to learn anything new itself. It just looks at the output and says, "Oh, this looks like Group A," or "This is new, let's make Group B."

3. The "Guardian" (Forgetting Control)

This is the most clever part. When the librarian learns a new task using a sticky note, there's a risk that the new note might accidentally mess up the old notes in the same group.

The Anchor: CRAFT takes a "snapshot" of what the group knew before the new task arrived. This is the Anchor.
The Safety Check: As the librarian learns the new task, CRAFT constantly checks: "Are you drifting too far away from what the group used to know?"
The KL Signal: It uses a mathematical measure called KL Divergence (think of it as a "Drift Meter") to measure the distance between the new behavior and the old behavior.
- If the drift is small, the new note is safe to keep.
- If the drift is huge (meaning the new task is too different and would ruin the old ones), the system stops the training or moves the task to a new group.
The Merge: Once the task is learned safely, the new note is merged back into the group's shared pile, updating the group's knowledge without breaking the old stuff.

Why is this better?

Efficiency: It uses far fewer "sticky notes" (parameters) than other methods because it shares notes between similar tasks.
No Forgetting: Because the original brain is frozen and the notes are carefully managed, the librarian remembers everything it learned yesterday while learning today.
Simplicity: It doesn't need a complex "gating" system to decide what to do; it just looks at the output and organizes naturally.

The Bottom Line

CRAFT treats continual learning not as "rewriting the brain," but as organizing a library of sticky notes. By keeping the brain frozen and using a single "Drift Meter" to ensure new notes don't mess up old ones, it allows Large Language Models to learn forever without forgetting who they are.

Technical Summary: CRAFT – Forgetting-Aware Intervention-Based Adaptation for Continual Learning

1. Problem Statement

Large Language Models (LLMs) suffer from catastrophic forgetting when adapted to new tasks via fine-tuning. This occurs because standard fine-tuning updates the same parameters that encode prior knowledge, creating an inherent trade-off between plasticity (learning new tasks) and stability (retaining old ones). Existing solutions—such as regularization (e.g., EWC), replay mechanisms, or architectural constraints like LoRA pools—operate within parameter space, where the conflict originates. These methods often require learned gating mechanisms (which are themselves susceptible to forgetting) or fixed references that fail to capture evolving shared knowledge.

The paper posits that continual learning should be reframed not as a problem of parameter competition, but as the organization and control of representation-level interventions. By keeping the backbone weights frozen and editing hidden representations in a low-rank subspace, the source of weight-level interference is removed. However, challenges remain in representation-based learning: how to share capacity across similar tasks without forcing unrelated tasks to compete, how to route tasks without a learned gate, and how to control forgetting during adaptation without limiting efficiency.

2. Methodology: CRAFT

CRAFT (Continual Representation-Anchored Fine-Tuning) is a framework that performs routing, adaptation, and merging entirely in representation space without modifying model weights. It leverages LoReFT (Low-rank Linear Subspace ReFT), which edits hidden states $h^{(l)}$ at specific token positions using a low-rank intervention function $\Phi(h^{(l)}; \phi) = h^{(l)} + R^\top(W h^{(l)} + b - R h^{(l)})$ .

The framework operates in three unified stages driven by a single Kullback–Leibler (KL) divergence signal:

A. Intervention Architecture

CRAFT splits interventions across two prompt streams within the residual stream:

f-stream: Applied to the first $t_{pos}$ tokens (prefix), encoding instructions.
l-stream: Applied to the last $t_{pos}$ tokens (suffix), where output is committed.
Tasks within a similar-task group $S_k$ share a common intervention state $\phi_{S_k}$ , while tasks in different groups remain isolated.

B. Deterministic Routing (No Learned Gate)

Instead of a trainable router, CRAFT uses output-distribution divergence to assign tasks:

Warm-up: A new task $\tau_t$ undergoes a brief warm-up ( $S_{wu}$ steps) from a shared random seed to produce a provisional intervention $\tilde{\phi}^{(t)}$ .
Distance Calculation: The output distribution $\pi_{\tilde{\phi}^{(t)}}$ is compared against the stored distributions of existing groups $S_k$ using a normalized symmetric KL distance:
$d(t, k) = \frac{D_{KG_k}}{\max(\min(D_K, D_{G_k}), \epsilon)}$
where $D_K$ is the distance of the new task from the baseline, $D_{G_k}$ is the group's distance from baseline, and $D_{KG_k}$ is the distance between the task and the group.
Assignment: If $d(t, k) \le \delta$ , the task joins group $S_k$ . Otherwise, a new group is seeded. This requires no trainable routing parameters or task identifiers.

C. KL-Regularized Adaptation and Merging

Once assigned to a group $S_k$ :

Anchoring: The group's current state $\phi_{S_k}$ is frozen as an anchor $\phi_{anchor}$ .
Training: The task's intervention $\phi^{(t)}$ $ϕ^{(t)}$ is trained on the new task with a loss function:
$L_{total} = L_{\tau}(\phi^{(t)}) + \beta \cdot KL(\pi_{\phi_{anchor}} \parallel \pi_{\phi^{(t)}})$
The KL term acts as a unified signal that:
- Regularizes training to prevent drift from the group's prior knowledge.
- Predicts forgetting: Based on empirical laws (Shenfeld et al., 2025), high KL divergence correlates with forgetting. If the initial epoch's mean KL exceeds a threshold $\eta$ , the task is evicted to a new group.
Merging: Upon convergence, the trained $\phi^{(t)}$ overwrites the shared state $\phi_{S_k}$ .

3. Key Contributions

Intervention-Level Continual Learning: CRAFT is the first framework to jointly perform routing, adaptation, and merging entirely in representation space without modifying model weights.
Deterministic Routing without Learned Gates: It eliminates the need for trainable routing parameters by using a brief warm-up and output-distribution KL distance to assign tasks, making the router robust to forgetting.
Unified Forgetting Control: It introduces a single KL-based signal that simultaneously regulates training drift, predicts forgetting, and governs the integration of new knowledge, replacing disjoint heuristics.
Empirical Validation: The approach is validated across three distinct LLMs (Llama-3.2-1B, Gemma-2B, Llama-2-7B) and diverse benchmarks (TRACE, Math-LLM, O-LoRA sequences).

4. Experimental Results

CRAFT was evaluated against strong baselines including SeqLoRA, GEM, EWC, L2P, DualPrompt, HiDeLoRA, O-LoRA, TreeLoRA, and recent methods like SAPT and TASL.

Performance Gains: CRAFT improves Overall Performance (OP) by up to 8.03% (on Llama-3.2-1B) compared to the best state-of-the-art methods.
Forgetting Reduction: It reduces the Backward Transfer (BWT) forgetting rate by up to 6.49%. On the 15-task stream with Llama-3.2-1B, CRAFT achieved a BWT of 2.60% compared to 6.41% for TreeLoRA and 10.99% for O-LoRA.
Parameter Efficiency: CRAFT uses 3.75 times fewer trainable intervention parameters than strong LoRA-based baselines. For example, on Llama-3.2-1B with 15 tasks, CRAFT required only 4.20M parameters versus 15.73M for standard LoRA.
Robustness: The method remains robust across different task orderings and is insensitive to variations in the routing threshold $\delta$ and warm-up length $S_{wu}$ within a wide plateau.
Cross-Group Invariance: Theoretical and empirical analysis confirms that training a task in one cluster does not affect the inference output of tasks in other clusters, as the optimizer scope touches only the specific group's intervention.

5. Significance and Claims

The paper claims that controlling adaptation in representation space, guided by output-space divergence, provides a scalable and principled approach to continual learning.

Reframing the Trade-off: By removing weight updates, CRAFT shifts the stability-plasticity trade-off from a parameter-space tug-of-war to a problem of organizing representation edits.
Principled Forgetting Control: The use of KL divergence as a unified signal allows the system to directly measure and control forgetting rather than relying on proxies.
Scalability: The framework scales with the number of discovered task groups ( $K$ ) rather than the total number of tasks ( $T$ ), offering a more efficient solution for long task streams.
Limitations: The authors acknowledge that the routing mechanism may struggle with near-ceiling tasks or streams where tasks are near-duplicates but presented sequentially (e.g., two halves of the same dataset), as the symmetric KL distance may saturate. They suggest future work could involve seeding warm-ups from existing clusters to handle such cases.

In essence, CRAFT demonstrates that catastrophic forgetting can be effectively controlled at the level of model outputs through structured representation editing, without the need to constrain or modify the underlying base weights.