acceptodds
Withdrawn from ICLR 2027

CATL: Conflict-Aware Test-Time Learning

Withdrawn from ICLR 2027, so left out of the paper lists and the map.

Abstract

This paper studies how to rapidly acquire useful information from test-time contexts. Existing test-time learning (TTL) methods either rely on dedicated offline pretraining, or adapt lightweight parameters online without explicitly controlling the interactions among successive updates, making information encoded from earlier context portions vulnerable to interference and overwriting in long contexts. To overcome this challenge, we propose *Conflict-Aware Test-Time Learning* (CATL), a plug-and-play TTL method that casts sequential context adaptation as an online continual-learning process and introduces a conflict-aware update mechanism guided by a compact historical write memory. The memory is constructed from the optimizer update, capturing the subspace, orientation, and importance of previous writes. Guided by the memory, CATL selectively attenuates only update components that conflict with important historical writes, while preserving compatible and orthogonal directions. It thus can mitigate destructive cross-chunk interference without replaying prior context or requiring additional offline training. Experiments on long-context retrieval and reasoning tasks show that CATL outperforms all evaluated baselines at the maximum supported context length across Qwen3 base models ranging from 1.7B to 8B parameters. CATL also improves performance on instruction-tuned backbones with different attention architectures while maintaining favorable inference-time efficiency.

Primary area:
foundation or frontier models, including LLMs
Keywords:
Test-time learning, long-context language models, online adaptation, continual learning

Reviews

Among:
Shape:
1234this paper, Bottom 10%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.67 over 3 reviews, above 10% of the others.
Reviewer_UTLXOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper proposes CATL, a plug-and-play method for sequential test-time adaptation on long contexts. It updates selected MLP down-projection matrices and maintains a memory of previous parameter writes, including their subspace, accumulated directions, and importance. Incoming update components that oppose this memory are attenuated, while compatible and orthogonal components are retained. Experiments on BABILong and selected RULER tasks cover three Qwen3 base models and two instruction-tuned backbones. The paper reports improvements at 32K context length, together with component ablations and runtime and memory comparisons.

Critical strengths
  • The method provides a concrete, replay-free way to distinguish compatible from conflicting historical writes. Preserving compatible components addresses a meaningful limitation of indiscriminate subspace projection.
  • Improvements at 32K are consistent across the three base-model sizes, with additional gains on instruction-tuned models. This supports the usefulness of the adaptation recipe across several backbones.
Critical weaknesses
  • The incremental benefit of the proposed mechanism is insufficiently established. The only matched naive-TTL comparison is Table 3, where CATL improves overall accuracy from 40.71 to 41.39. Without this baseline across the main settings or uncertainty estimates, the larger comparisons do not isolate the contribution of conflict handling.
  • Historical parameter-write alignment is only a proxy for retaining earlier information. Non-expansiveness does not establish preservation of previous losses, and a norm-matched shrinkage control is missing. Moreover, the motivating naive-TTL visualization uses 4K contexts, whereas Appendix F evaluates CATL at 32K.
  • Comparison fairness is unclear: CATL uses configuration-specific learning rates, while the competing methods use fixed recipes (Appendix C). The selection data, per-setting choices, and comparable tuning budgets are not sufficiently documented.
Questions for authors
  1. Table 3 shows a relatively small gain over matched naive TTL. Can you report this comparison across the main model and benchmark settings, with paired uncertainty estimates, to clarify how consistently conflict handling improves over the underlying TTL procedure?

  2. Does CATL outperform a control that uniformly rescales each naive-TTL update to match CATL's update norm? This would help distinguish the benefit of selectively handling conflicting directions from the benefit of simply taking smaller updates.

  3. Can you compare CATL and naive TTL under the same 32K setup and measure how later updates affect losses on earlier chunks? The current write-alignment analysis does not directly establish that earlier information is better preserved.

  4. How were CATL's configuration-specific learning rates selected, and which development data and search ranges were used? Do the comparative gains persist when competing methods receive comparable tuning budgets under the same selection protocol?

Reviewer_9NgsOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes CATL (Conflict-Aware Test-Time Learning), a test-time adaptation method for long-context LLM inference that splits a long context into sequential chunks and updates selected MLP down-projection weights for T = 2 self-supervised steps per chunk. To mitigate cross-chunk interference, CATL maintains an orthogonal basis S and importance weights via incremental SVD on the chunk weight updates Q, selectively attenuating negative projections along basis columns while leaving positive projections and orthogonal residuals unchanged.

Critical strengths
  1. Relevant problem setting: Addressing cross-chunk interference during sequential test-time learning (TTL) on long contexts is practical and well-motivated.
  2. Consistent gains over frozen baselines: Across LongBench v1/v2 and RULER, CATL improves over the unadapted Frozen model with modest latency overhead (~12% at 32K context).
Critical weaknesses
  1. Omission of naive TTL from main Tables and inconsistent Base vs. Instruct evaluation: Comparing the main tables (Tables 1, 2, 4, 5) with the 32K ablation table (Table 3 on Qwen3-4B-Base) shows that 70%–78% of CATL's reported improvement comes simply from running 2 steps of unprojected Naive TTL on the MLP down-projection layers, rather than from conflict-aware projection: while Base Model scores 60.39% on RULER and 9.67% on BABILong (38.65% overall), Naive TTL already reaches 62.82% (+2.43%) and 11.22% (+1.55%) (40.71% overall), whereas full CATL adds only +0.69% on RULER (63.51%) and +0.67% on BABILong (11.89%) (+0.68% overall at 41.39%), yet Naive TTL is omitted from all main tables. Furthermore, Table 1 evaluates zero-shot QA (which requires strict answer formatting) on pretrained Base models (Qwen3-Base), inflating relative gains via formatting adaptation; when switching to the instruction-tuned Qwen3-4B in Table 2 (and Tables 4–5), all TTL baselines (qTTT, Locas-Memory, Naive TTL) are omitted and CATL's average gain over the unadapted model drops to just +0.93% (even underperforming on 4K RULER and 16K BABILong).
  2. Conceptual mismatch between left-subspace weight projection and input-activation null-space projection: In classic subspace continual learning (e.g., GPM, Saha et al., 2021; SGP, Saha & Roy, 2023; Adam-NSCL, Wang et al., 2021) and null-space knowledge editing (e.g., AlphaEdit, Fang et al., 2025), the protected subspace is constructed from layer input activations X(old) of dimension d2 × N, and weight updates ΔW of dimension d1 × d2 are projected on the right (the input dimension d2) so that ΔW X(old) ≈ 0, directly guaranteeing that the layer's output on earlier inputs is preserved. In contrast, CATL extracts the left singular vectors S (in the output dimension d1) of the weight update Q and leaves the orthogonal residual D(res) = (I - S S^T) D completely unattenuated (Eq. 14). However, orthogonality in the left (output) column space does not imply ΔW x(old) = 0: whenever the row space of D(res) has non-zero overlap with earlier chunk activations x(old) in the input space, D(res) x(old) ≠ 0 will still alter the MLP output on earlier chunks' tokens and cause cross-chunk interference.

References

  • Junfeng Fang et al., AlphaEdit: Null-Space Constrained Knowledge Editing for Language Models, ICLR 2025.
  • Gobinda Saha et al., Gradient Projection Memory for Continual Learning (GPM), ICLR 2021.
  • Shipeng Wang et al., Training Networks in Null Space of Feature Covariance for Continual Learning (Adam-NSCL), CVPR 2021.
  • Gobinda Saha and Kaushik Roy, Continual Learning with Scaled Gradient Projection (SGP), AAAI 2023.
Questions for authors
  1. Can the authors report the performance of Naive TTL (and Temp-Lora / MTTT) across all models and context lengths (4K–32K) in Tables 1, 2, 4, and 5?
  2. Why did the authors choose to apply SVD and projection in the left (output) subspace of Q, where the unattenuated orthogonal residual D(res) = (I - S S^T) D can still yield D(res) x(old) ≠ 0, rather than projecting in the right (input activation) subspace of previous chunks (as in GPM, SGP, and AlphaEdit, where ΔW X(old) ≈ 0 directly bounds output drift)?
Reviewer_9CSqOpenReview ↗
Rating
1
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper studies test-time learning (TTL) for long contexts, where the model reads the input in chunks and adapts a few of its weights on each chunk at test time to compress the context and use it to produce an answer. The authors observe that an update on a new chunk can hurt what was learned from earlier chunks, and they treat this as a continual learning problem. Their method, CATL, keeps a small memory of past updates and shrinks only the parts of a new update that point against them. On BABILong and four RULER subtasks with Qwen3 and Gemma3-1B models, CATL shows some gains over the base model and two TTL baselines, mostly at 32K-token context length.

Critical strengths
  1. The problem is clearly framed. The paper links chunk-by-chunk TTL to continual learning in a clear way, and Figure 1 gives a simple way to measure how updates on new chunks affect earlier ones.
  2. The method is simple and easy to use with a plug-and-play module. It requires no offline training or replay of earlier chunks, and the extra memory is small.
  3. The selective rule is better motivated than plain projection. The ablation shows that keeping the compatible parts of an update works better than removing everything in the past subspace, which supports the paper's main design choice.
  4. The writing is pretty easy to follow, understandable, and describes the method clearly.
Critical weaknesses

W1: Novelty & impact

  1. The paper offers a new update rule, but not a new insight. The problem of later updates overwriting earlier ones is already known from prior chunk-wise TTL work. The method builds on Scaled Gradient Projection, and its rule of removing only the conflicting part of an update works much like PCGrad. I think the paper needs to teach the field something new about TTL, for example, that interference is the main reason TTL fails, or how it grows with the number of chunks. The paper does not show either of these sufficiently, so it is hard to say what readers learn beyond a new rule with small gains.
  2. It is unclear when CATL is needed in practice. All contexts in the paper fit inside the model's context window, and after adaptation, the model still reads the full context to answer. CATL therefore adds training cost on top of normal inference without adding clear advantages. The paper gives only a general reason for using TTL and does not show what it adds to attention over the full context. The setting where TTL should matter most, inputs much longer than 32K, is not tested. The paper reports performance, memory, and latency only up to 32K, while the performance and cost at longer lengths are much more valuable in practice. Experiments beyond the context window are needed, together with a comparison to standard context-extension methods such as YaRN or the Dual Chunk Attention used in Qwen2.5-1M.

W2: Sufficient support of claim & Significance

  1. The results do not show that the conflict-aware mechanism causes the gains.
  • The key baseline, naive TTL, is missing from the main results. Naive TTL (assuming the same setup without the conflict-aware projection) appears only in the ablation, for one model at 32K. Naive TTL alone already improves over the base model by about 2.4 points on RULER and 1.6 points on BABILong. CATL adds only about 0.7 points on top of that. The main tables therefore cannot support the claim that the proposed mechanism, rather than TTL itself, causes the gains. Naive TTL should be reported in every setting, and the gap between CATL and naive TTL should be compared with the variation across random seeds. It should also be tested in settings where the number of chunk updates grows, for example, longer contexts with a fixed chunk size.
  • The gains are also small, while the claims are too strong. CATL is worse than the base model in several settings, and its average gain on the instruction-tuned Qwen3-4B is under 1 point. The highlighted 38.1% relative accuracy gain is a change of about 3.6 points at very low accuracy. A fair claim would be that, at 32K, CATL gains about 1 to 3.5 points over the base model, and its gains at shorter lengths are mixed.
  1. The paper does not show that interference is the problem CATL solves.
  • First, the experiments cannot clearly test the claim that longer contexts cause more interference. The chunk size grows with the context length, so every setting has about 8 chunks. A longer context only means larger chunks, not more updates in a row. To fully test this claim, the authors should keep the chunk size fixed and increase the number of chunk updates.
  • Second, the motivation is not connected to accuracy. Figure 1 shows that training on a new chunk often raises the loss on earlier chunks. However, a higher loss does not mean that information needed for the answer was lost. Also, the model reads the full context again at answer time, so earlier chunks are still available through attention. The paper does not directly show that this interference causes wrong answers, or that CATL's gains come from fixing it. A simple test is to check whether CATL helps more when the answer is in an early chunk. More broadly, a more complete analysis is needed to show that chunk interference hurts actual performance, and that CATL reduces this interference and thereby improves performance.
  • Third, the benchmarks do not test the advantages the paper advertises. The paper presents CATL as a TTL method that treats chunk-by-chunk adaptation as online continual learning, and thus reduces interference between updates and balances stability and adaptation. However, none of the tasks are built to measure these properties. It is unclear what kind of conflict BABILong QA1–QA3 create. These tasks hide a few short facts in unrelated text. In QA1, the answer is simply the most recent fact, so newer information should replace older information, not be protected against. QA2 and QA3 do need older facts, but the paper does not show that these facts sit in early chunks or that later chunks overwrite them. The RULER tasks do not create such conflicts by design either. The continual learning setting is also very small. Each example has only about 8 chunks and 16 updates, and the weights and memory are reset before the next example. This is too short to show forgetting over many updates. The paper measures interference only through update directions and changes in loss, not through task accuracy. As a result, there is no direct benchmark evidence that CATL reduces harmful interference over many updates. A convincing evaluation needs tasks where the answer depends on early information that later updates are likely to overwrite. It should also include much longer update sequences, where forgetting can be measured directly.
  1. The baselines are too weak, and the comparison is neither fair nor complete.
  • The baselines are too weak to show a real advantage. In most settings, both TTL baselines score below the base model, and qTTT nearly collapses on BABILong with the 4B model. Both baselines use a single fixed learning rate, while CATL's learning rate is chosen per setting. I do not think this is a fair setup. At 32K, where the paper claims to beat all baselines, no baseline beats the base model by more than about 1.3 points. Beating these baselines therefore says little about CATL's real advantage. The authors should confirm that their qTTT implementation reproduces the original results and tune all baselines as carefully as CATL.
  • The comparison is also not matched for compute. Although the paper reports runtime and memory, accuracy is not compared at a matched compute budget. This matters most against the base model, which spends no extra compute. Without a compute-matched non-TTL baseline, it is unclear whether CATL's gains come from the method or simply from spending more compute at test time. The same compute-matched comparison should also be applied to the TTL baselines.
  • Several important baselines are missing. The most important are: naive TTL with a tuned learning rate; Temp-LoRA, a closely related prior chunk-wise TTL method; simple continual learning methods such as weight regularization or replay of earlier chunks; conflict-based methods such as PCGrad and A-GEM; and In-Place TTT, which the paper groups with TTL methods for pretrained models but does not compare against. Since the context fits in the window, a retrieval baseline would also show whether TTL is needed at all. The paper excludes TTL methods that need a new architecture or extra pretraining, such as End-to-End TTT, and linear-attention models such as DeltaNet. This scope is reasonable, but the paper compares with these approaches only in words. A rough comparison of accuracy and cost would show whether a plug-and-play method is competitive.

Additional suggestions

  1. Some design choices are not justified. Conflict is measured on the optimizer's updates with Adam by default, which rescale each coordinate, rather than on raw gradients. It would be good to discuss why this is better than measuring conflict on raw gradients. In addition, the stability property in the Remark is a per-step property that follows directly from the definitions. It does not show that adaptation over many chunks is stable.
Questions for authors
  1. How is "directional conflict" in Figure 1(b) computed?
  2. How many test questions does each benchmark and context length contain?
  3. What is the variance across the three random seeds?
  4. Does naive TTL in Table 3 use exactly the same layers, chunks, steps, and learning rate as CATL? Were the baselines tuned as carefully as CATL?
  5. In BABILong QA2 and QA3, do the needed older facts fall in early chunks? Why were the needle-in-a-haystack tasks excluded from RULER?

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Discussion (0)

Sign in to comment.