acceptodds
Under review as a conference paper at ICLR 2027

Verified Cognitive Schema Transfer for Test-Time Learning

Abstract

Test-time scaling improves the problem-solving capabilities of large language models (LLMs) by allocating additional inference compute to each problem. Existing memory-augmented methods enable problem-solving experience to accumulate and transfer across tasks, but accumulated experience does not automatically yield a systematic understanding of solution principles. A key challenge is to use verification feedback to abstract structures shared across concrete problem-solving experiences and organize them into cognitive schemas with explicit applicability conditions that guide subsequent reasoning. To address this challenge, we introduce Verified Cognitive Schema Transfer (VCST), a framework for accumulating and reusing knowledge during inference without updating model parameters. VCST extracts task-level schemas from verified solutions, abstracts shared solution structures across tasks, and reuses the resulting schemas after checking their applicability conditions. For new tasks, it retrieves and applies relevant knowledge through tag-based filtering and semantic reranking. Under a fixed API budget, VCST adaptively balances cognition construction and task solving. Experiments across four benchmark suites, 13 benchmarks, and nine backbone LLMs show that VCST improves accuracy over strong test-time scaling baselines. On LiveCodeBench, VCST improves the final solve rate over S∗ by 6.1–20.7 percentage points across nine backbone models, and enables a 7B model to outperform a 32B model equipped with S∗. VCST also generalizes broadly, improving over the strongest corresponding baselines by 2.2–2.4 points on multi-task reasoning and 8.7 points on code execution prediction. On multi-language code generation, VCST achieves the highest accuracy in all six evaluated languages.

Primary area:
foundation or frontier models, including LLMs
Keywords:
Test-Time Scaling, Test-Time Learning, Large Language Models, Persistent Cognition

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 3 reviews, above 85% of the others.
Reviewer_GCrGOpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper proposes Verified Cognitive Schema Transfer (VCST), a training-free framework that stores and reuses problem-solving knowledge across a stream of tasks at test time. When a candidate solution passes a verifier, an LLM summarizes it into a structured schema entry and then store it in a persistent memory. For each new task, VCST retrieves schemas through tag-based Jacquard filtering and uses the LLM to check their applicability and rerank them, keeping at most two. It then includes the retrieved schemas in the generation prompt to produce candidate solutions. Under a fixed API budget, the LLM also decides at each step whether to solve a task, synthesize provisional schemas, or consolidate existing ones. Experiments on LiveCodeBench, multi-task reasoning, code reasoning, and multi-language code generation show that VCST outperforms test-time scaling and memory-based baselines.

Critical strengths
  • The evaluation is broad, covering 13 benchmarks across four task groups and nine backbones from three model families (GPT, Qwen2.5-Coder, and DeepSeek-R1-Distill) and scales on LiveCodeBench.
Critical weaknesses
  • The core idea of distilling successful solutions into reusable memory and retrieving them for later tasks has been explored extensively, but several closely related works are not cited. Buffer of Thoughts retrieves distilled thought templates for new problems, and Agent Workflow Memory induces reusable workflows from successful trajectories in an online setting. Dynamic Cheatsheet addresses essentially the same problem of test-time learning with an adaptive memory over a stream of tasks. Given this prior work, the contribution appears to reduce to verified-only admission and an applicability field in each memory entry. The authors should discuss these works, clarify what is specific to VCST, and include Dynamic Cheatsheet as a baseline.
  • For benchmarks without an executable verifier, such as MATH and MMLU-CF, the correctness feedback can only come from ground-truth answers, a stronger assumption than label-free memory methods. The memory baselines were also originally designed for agentic or conversational settings, and ReasoningBank relies on an LLM judge rather than labels. The paper should state the feedback source for each benchmark, describe how each baseline was adapted and what feedback it received, and report a variant of VCST without correctness feedback.
Questions for authors
  • On LiveCodeBench, does the verifier V use only the public tests, or does it overlap with the hidden tests used for scoring?
  • The large gains over S* are reported in Figure 3, where VCST repairs failed candidates and revisits unsolved tasks. However, API calls per problem are reported only for the single-visit setting in Table 1, and only a lower bound of 16 calls is given for S*. How many model calls per problem do VCST and S* use in the Figure 3 setting, and what value of the budget B is used?
3 comments
AuthorsOpenReview ↗

Response to Reviewer GCrG

We thank the reviewer for the constructive comments.

1. Related work and contribution. We now cite and discuss Buffer of Thoughts, Agent Workflow Memory and Dynamic Cheatsheet (Section 2.2).

VCST asks how inference-time knowledge can advance unfinished tasks within a shared budget. In full code-solving, VCST starts with empty memory and revisits unresolved tasks after other tasks yield or improve schemas: later experience can help complete earlier unfinished problems.

Knowledge construction is itself a choice about where to spend inference computation. Using task state S and knowledge state K, VCST allocates budget B between searching for particular answers and building knowledge useful across tasks, through solve, explore and optimize. Round-robin orders task visits; adaptation selects operations (Sections 3.1–3.3; Appendix G, Algorithm 1).

Schemas abstract feedback-supported experience into shared strategies and parameterized templates, with provenance and applicability conditions compared with new task constraints. Abstraction provides transferable solving structures; applicability assessment determines where to reuse them.

We add ablations of abstraction (Full 88.3%, task-level-only 85.0%) and applicability (semantic-only 86.3%; Table 4), plus same-pool retrieval and paired-removal tests of reuse (Appendix H).

2. Dynamic Cheatsheet baseline. We add a matched comparison with task-adapted Dynamic Cheatsheet-Cu, retaining its released curator and full-cheatsheet context. Both methods use GPT-5-nano, the same 240-task LiveCodeBench order, empty initial memory, public feedback and solver: five candidates/visit, up to three repair rounds for the top two, at most two visits/task.

VCST solves 212/240 (88.3%), versus 206/240 (85.8%) for DC-Cu: six more tasks, or 2.5 percentage points. This tests the complete memory systems under matched feedback (Section 4.5; J.2, Table 13).

3. Feedback assumptions and adaptation. We agree that reference grading is a stronger deployment assumption. In Table 2, MATH/GSM8K/BBH/MMLU-CF use reference grading, MBPP/HumanEval+ execution checks, and LongBench reference-based metrics. Other code tasks use execution checks; HaltEval uses halting labels. In single-submission runs, feedback arrives after answers are fixed and updates subsequent-task memory only (Section 4.2; Appendix F).

ExpeL, A-MEM and ReasoningBank all receive post-submission benchmark feedback: task, own answer, success/failure and feedback text. They retain insight extraction, linked-note updates and success/failure reflection, respectively; VCST admits source experiences judged successful.

We add a method × feedback experiment comparing VCST and ReasoningBank on MATH/GSM8K/BBH/MMLU-CF with GPT-4o-mini, to test use without external labels. Conditions share generation settings, start with independent empty memories and receive either reference-feedback bits or bits from a shared judge without reference answers. Judge rationales are excluded from updates; under self-judging, reference scoring only evaluates frozen answers. VCST's mean falls 85.48→83.38 (−2.10 points), but it leads ReasoningBank by 1.68 points with reference feedback and 1.78 with self-judging. Thus, the gain persists without external correctness labels in this control, reported separately from Table 2 (Section 4.5, Figure 5; J.1, Table 12).

4. Public versus hidden tests. We clarify: LiveCodeBench uses public tests for ranking, repair and memory admission. Hidden tests score frozen final programs only; their contents/results never enter generation, repair, retrieval, schema construction, action selection, revisits or stopping. Both sets test the same problems (Section 4.1; H.2/J.2). Appendix E/Table 9 separately reports public-test diagnostics.

5. Full-process costs and budget. We add full-process costs for all 511 tasks and nine backbones, including memory overhead and revisits (Appendix I, Figure 7). Figure 3's cap is B=20,000 model calls/run; VCST generates five candidates/visit, repairs the top two for up to three rounds, and allows at most three visits/task.

BackboneS* calls/taskVCST calls/task
Qwen-Coder-7B36.924.7
Qwen-Coder-14B32.321.8
Qwen-Coder-32B28.818.8
GPT-4o-mini31.515.9
GPT-4.1-nano30.118.1
GPT-5-nano24.912.2
R1-Distill-7B33.422.9
R1-Distill-14B29.519.4
R1-Distill-32B25.816.5

All generation, repair, retrieval, schema construction/maintenance, action-selection and retry calls count; tokens include input/output and supplied memory. Totals are divided by all 511 tasks, including failures; revisits add consumption, not tasks. VCST uses 31.4–51.0% fewer calls and 39.2–51.4% fewer tokens across paired backbones. Table 1's 5.8–7.9 calls/task covers one visit without repair/revisits; S*'s 16 samples likewise exclude debugging. These are realized costs.

Thank you for the concise response and the additional experiments. The results now clearly show that your method achieves better performance across various tasks and models, as well as better efficiency than S*. Still, I find the methodological novelty somewhat limited. Revisiting can only be applied to contest-style settings. For the dynamic allocation, Table 4 shows a modest gain compared to a fixed policy. Since most of my concerns have been addressed, I have raised my rating from 2 to 3.

AuthorsOpenReview ↗

Response to Reviewer GCrG

Thank you for your updated assessment. We are pleased that the new experiments have addressed most of your concerns and made the performance and efficiency benefits clearer. The specific points raised in your review guided several of these additions and helped us improve the paper. We appreciate your reconsideration and constructive suggestions.

Reviewer_aPXQOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes Verified Cognitive Schema Transfer (VCST), a test-time learning framework that extracts reusable cognitive schemas from verified solutions and transfers them to subsequent tasks. The framework combines verification-based knowledge construction, applicability-aware retrieval, and adaptive task scheduling without updating model parameters. Experiments across multiple reasoning and code-generation benchmarks demonstrate improvements over existing test-time scaling and memory-augmented approaches.

Critical strengths

The paper addresses an important problem: how to accumulate and reuse knowledge across tasks during inference rather than treating each problem independently.

The experimental evaluation is extensive, covering multiple benchmarks and backbone models. The improvements on LiveCodeBench are particularly impressive, with gains of 6.1–20.7 percentage points over S*.

The paper includes useful ablation studies, memory diagnostics, and task-order robustness experiments. The results generally support the benefits of persistent memory and knowledge-guided retrieval.

The paper is generally well organized and easy to follow. The framework overview and examples help explain the main ideas.

Critical weaknesses

The paper has some interesting ideas and good experimental results, but I have a few concerns.

First, the novelty seems somewhat limited. Several key components, such as verified experience extraction, memory-based retrieval, and adaptive scheduling, have already been studied in previous work. The authors should explain more clearly how VCST differs from existing methods such as ReasoningBank and ExpeL, beyond combining these techniques into one framework.

Second, I am not fully convinced about the benefits of cross-task schema abstraction. The ablation studies show that memory and solution templates are useful, but they do not clearly show how much improvement comes from cross-task abstraction itself. It would be helpful to compare with a simpler version that stores verified task-level schemas without cross-task refinement.

Third, the paper uses an adaptive strategy to decide whether to solve tasks, explore, or optimize knowledge. However, I did not find a direct comparison with a simpler fixed strategy. Such an experiment would help show whether the adaptive decision mechanism is really necessary.

Finally, the applicability checking mechanism could be analyzed more carefully. The paper shows that the two-stage retrieval performs better than simpler retrieval strategies, but it is unclear how much of this improvement comes from applicability checking rather than semantic reranking. It would also be interesting to see how often incorrect schemas are selected and whether they negatively affect the results.

Questions for authors

What are the main technical differences between VCST and existing methods such as ReasoningBank and ExpeL? What is the key novelty beyond combining existing techniques?

Can the authors provide an ablation study that disables cross-task schema abstraction while keeping verified task-level memory? How much improvement actually comes from cross-task abstraction?

How much does the adaptive decision-making strategy contribute to the overall performance? Can the authors compare it with a simpler fixed strategy under the same computational budget?

How reliable is the applicability checking mechanism? How often are irrelevant schemas selected, and how do these incorrect selections affect the final results?

3 comments
AuthorsOpenReview ↗

Response to Reviewer aPXQ

We thank the reviewer for the constructive comments.

1. Technical distinctions from ReasoningBank and ExpeL. VCST asks how inference-time knowledge can advance unfinished tasks within a shared budget. In their original settings, ExpeL extracts insights from training tasks for unseen evaluation; ReasoningBank processes queries sequentially without future-query access (ExpeL, Sections 4.1–4.3; ReasoningBank, Section 3.1). VCST starts with empty memory and revisits unresolved tasks after other tasks yield or improve schemas: later experience can help complete earlier unfinished problems.

Knowledge construction is itself a choice about where to spend inference computation. Using task state S and knowledge state K, VCST allocates budget B between searching for particular answers and building knowledge useful across tasks, through solve, explore and optimize. Round-robin orders task visits; adaptation selects operations (Sections 3.1–3.3; Appendix G, Algorithm 1).

Schemas abstract feedback-supported experience into shared strategies and parameterized templates, with provenance and applicability conditions compared with new task constraints. Abstraction provides transferable solving structures; applicability assessment determines where to reuse them.

Table 4 supports abstraction (Full 88.3% vs 85.0% task-level only) and applicability assessment (86.3% semantic-only); Appendix H tests downstream effects. Matched-feedback gains persist (Figure 5). Task-pool revisits apply to full code-solving; single-submission reasoning tests forward construction and reuse.

2. Isolating cross-task abstraction. To test what abstraction adds beyond verified task-level memory, we compare Full with a version retaining extraction, templates and retrieval but disabling cross-task synthesis, consolidation and provisional-schema promotion.

With GPT-5-nano on the same 240 LiveCodeBench tasks (80 per difficulty), both start with independent empty memories, generate five candidates per visit and repair the top two for up to three rounds, with at most two visits/task. Public tests provide feedback; hidden tests score frozen final programs (Appendix J.2).

Full solves 212/240 (88.3%), versus task-level-only's 204/240 (85.0%). Hard improves from 67.5% to 75.0%. Thus, enabling abstraction above task-level memory adds 8 solved tasks (+3.3 points), including a 7.5-point gain on Hard (Table 4).

3. Adaptive versus fixed decisions under shared budgets. To test whether fixed maintenance can replace adaptation, we compare Full with fixed intervals k=3,6,9 on the same 200 randomly sampled LiveCodeBench tasks using GPT-4o-mini.

A fixed policy executes one maintenance operation every k completed task visits, alternating explore/optimize from explore without skipping. Full chooses solve/explore/optimize from task state without a fixed interval. All policies allow at most three visits/task; all model calls, including auxiliary/maintenance calls, count toward B. Accuracy uses all 200 tasks.

B (request cap)Fullk=3k=6k=9
2,40073.5%71.0%70.0%70.5%
4,80077.5%75.0%74.0%72.5%

At both budgets, Full solves 5 more tasks than the best fixed policy (+2.5 points), supporting state-dependent maintenance over these tested fixed schedules (Appendix J.3, Table 14).

4. Applicability, semantic relevance and downstream effects. We use three tests with GPT-5-nano.

To isolate applicability, semantic-only retains the shortlist (≤8), two-schema cap, threshold (0.65) and empty-selection option, replacing applicability assessment with relevance ranking. Under A2's 240-task setup, it solves 207/240 versus Full's 212/240: Full gains 5 tasks (2.1 points). Memories evolve independently (Table 4).

To test selection quality without different memory pools, we freeze Full's memory/shortlist at first visits on 511 tasks. Both selectors receive identical pools, select at most two schemas and use the same task–schema labels; semantic choices do not affect later memory. The inapplicable share among selected schemas falls 24.8%→4.6% (201/811→29/637), while tasks receiving an applicable schema rise 68.3%→72.6%. Selection thus improves without sacrificing useful coverage (H.1, Table 10).

To test downstream effects, we use two groups of 100 tasks with prespecified inapplicable/applicable targets from semantic selections. Otherwise matched branches start from the same frozen state/context, differing only in retaining/removing one target schema. Removal raises accuracy 63%→77% for inapplicable targets but lowers it 84%→73% for applicable targets (H.2, Table 11). Branches do not update memory or revisit tasks; public tests guide generation/repair, hidden tests score frozen finals. These opposite effects support distinguishing useful from misleading experience in the selected groups.

Reviewer_aPXQOpenReview ↗

Response to Author Rebuttal

Thank you for the detailed response and additional experiments.

The new ablation studies on cross-task abstraction and adaptive scheduling directly address my previous concerns. The additional analysis of applicability checking, particularly the controlled retrieval and schema-removal experiments, is also helpful and provides stronger evidence for the effectiveness of the proposed mechanism.

My remaining concern is the somewhat limited technical novelty compared with existing memory-based approaches. Nevertheless, I appreciate the additional experiments and clarifications, which have substantially addressed my concerns.

Based on the additional experiments and clarifications, I will raise my rating from Weak Reject to Weak Accept.

AuthorsOpenReview ↗

Response to Reviewer aPXQ

We sincerely thank you for the time and care you have devoted to reassessing our work, and for updating your recommendation. We greatly appreciate your constructive feedback and your recognition of the additional experiments and clarifications. Your comments have helped us strengthen the experimental evidence and communicate our technical contributions more clearly.

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

In this paper, the authors propose VCST, a framework that turns verified problem-solving experiences into reusable reasoning schemas without updating model parameters. It identifies shared solution patterns across tasks and checks their applicability before using them to guide future reasoning. Under a fixed API budget, experiments on 13 benchmarks show improvements over strong test-time scaling baselines.

Critical strengths
  • The paper addresses the repeated cost of solving related tasks independently. Retaining reusable solution knowledge allows computation spent on earlier problems to support later tasks.

  • VCST accumulates knowledge without updating model parameters, making the framework applicable to pretrained models accessed through APIs and avoiding additional model training.

  • Evaluation covers four benchmark suites and 13 benchmarks, with nine backbones on LiveCodeBench.

Critical weaknesses
  • The method depends on the order in which tasks contribute to memory, but the presented evaluation uses a predefined stream. Its gains may therefore depend on encountering useful prerequisite examples early, leaving performance under less favorable task orders uncertain.

  • Applicability checking relies on an LLM's judgment rather than directly testing whether the schema's conditions hold.

  • The framework depends on obtaining reliable correctness feedback after task completion. In settings where answers cannot be automatically verified, its knowledge-construction process requires feedback that may be unavailable during ordinary deployment.

Questions for authors

Please refer to the Critical Weaknesses.

1 comment
AuthorsOpenReview ↗

Response to Reviewer D3Dr

We thank the reviewer for the constructive comments. We clarify the mechanisms and report the added controls below.

1. Task-order dependence. Appendix C, Tables 7–8, evaluates multiple task orders. In Table 7, VCST and its matched no-memory variant use three independently shuffled orders. Each run starts with empty memory; each pair shares the task order and other solver settings.

MethodOrder 1Order 2Order 3Mean ± sample SD
VCST w/o Memory57.9%58.3%58.3%58.2 ± 0.2%
VCST76.9%77.1%76.5%76.8 ± 0.3%

The memory advantage is positive in every paired order, at 18.2–19.0 percentage points. A separate five-order evaluation on the 511-problem manifest reports 76.1–77.1% overall accuracy, with a mean of 76.7% and sample SD of 0.4 percentage points (Table 8). These results support robustness to the tested random permutations.

The revised Section 4.5 also clarifies why deferred revisits matter: unresolved tasks can benefit from schemas accumulated on later tasks. The sequential single-pass variant scores 83.3%, compared with 88.3% for Full, while retaining candidate generation and repair within each visit (Table 4).

2. Reliability of applicability checking. We agree that LLM-based applicability judgments can be mistaken. In the second retrieval stage, the LLM compares each candidate schema's stated applicability conditions with the current task's constraints and algorithmic requirements, rather than selecting on topical similarity alone. If no candidate is judged applicable, it returns an empty selection (original Section 3.2). To evaluate the reliability and practical value of this judgment, we have added a controlled retrieval audit and paired schema-removal experiments in Appendix H.

Controlled retrieval audit (H.1, Table 10). On 511 LiveCodeBench tasks with GPT-5-nano, both selectors receive the same frozen memory and candidate pool and may select at most two schemas. Identical task–schema pairs receive the same applicability label. Compared with semantic-only reranking, VCST reduces the inapplicable share among selected schemas from 24.8% (201/811) to 4.6% (29/637), while increasing the fraction of tasks receiving at least one applicable schema from 68.3% (349/511) to 72.6% (371/511).

Paired schema removal (H.2, Table 11). Each applicability group contains 100 tasks; targets are fixed before observing branch outcomes. Each pair starts from the same frozen state and context and retains or removes only one target schema under matched solver settings and budget limits. Removing an inapplicable schema increases private-test correct answers from 63/100 to 77/100 (+14 percentage points); removing an applicable schema decreases them from 84/100 to 73/100 (−11 points). These results provide empirical support for the selection reliability and downstream value of applicability assessment under the tested conditions. Full protocols and results are reported in Appendix H.

3. Availability of correctness feedback. We agree that reliable external feedback is not always available. VCST uses task verifiers where available; we added an LLM-self-judged variant for operation without external correctness labels. Section 3.2 distinguishes externally verified from self-judged admission.

Using GPT-4o-mini, we compare VCST and task-adapted ReasoningBank under matched reference feedback and matched self-judging (Section 4.5, Figure 5; Appendix J.1, Table 12). Conditions share task order and answer-generation settings, with separate empty memories for every method, feedback condition and benchmark. Each task has one final submission; a correctness bit arrives afterward and updates subsequent-task memory only. In self-judged conditions, reference answers and reference-scored outcomes enter neither generation nor memory updates; references only evaluate frozen submissions. Judge rationales are excluded from updates.

MethodFeedbackMATHGSM8KBBHMMLU-CFMean
ReasoningBankReference83.695.484.471.883.80
VCSTReference85.297.385.873.685.48
ReasoningBankSelf-judge81.293.982.069.381.60
VCSTSelf-judge83.896.282.670.983.38

Scores are 0–100; means are unweighted across four benchmarks. With self-judging, VCST's mean falls from 85.48 to 83.38 (−2.10 points), and ReasoningBank's from 83.80 to 81.60 (−2.20). VCST retains a 1.78-point advantage, versus 1.68 points with reference feedback. Thus, the advantage persists without external correctness labels in this controlled comparison, reported separately from Table 2's seven-benchmark experiment. Full settings and update rules are in Appendix J.1.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.