MemCollab: Cross-Model Memory Collaboration via Contrastive Trajectory Distillation

Yurui Chang; Yiran Wu; Qingyun Wu; Lu Lin

cs.AIMar 24, 2026

MemCollab: Cross-Model Memory Collaboration via Contrastive Trajectory Distillation

Authors: Yurui Chang, Yiran Wu, Qingyun Wu, Lu Lin

Organizations: Pennsylvania State University · AG2AI

Abstract

LLM agents increasingly rely on memory mechanisms to reuse knowledge from past problem-solving experiences. However, existing methods typically construct memory for a single agent and reuse it with the same underlying model, tightly coupling stored knowledge to model-specific reasoning styles. In heterogeneous deployments, where agents may be instantiated with backbone models of different sizes, architectures, or specializations, this raises a key question: can a single memory system be shared across agents with different backbone models? We find that naive cross-model memory transfer can degrade performance, because stored memories often entangle task-relevant knowledge with model-specific biases. To address this challenge, we propose MemCollab, a collaborative memory framework that builds shared cross-model memory by contrasting reasoning trajectories generated by different model-based agents on the same task. Through this contrastive process, MemCollab distills abstract reasoning constraints that capture shared task-level invariants while suppressing model-specific artifacts. We further introduce a task-aware retrieval mechanism that conditions memory access on task category, ensuring that only relevant constraints are retrieved at inference time. Experiments on mathematical reasoning and code generation benchmarks show that MemCollab consistently improves both accuracy and inference-time efficiency across diverse agents, including settings with different model families. These results demonstrate that collaboratively constructed cross-model memory can serve as a shared reasoning resource for heterogeneous LLM-based agents.

Figures & tables

Figure 1: Accuracy on MATH500 dataset with memory from different resources.

Figure 2: Framework of MemCollab . Left : Using different agents to generate trajectory pairs for the same task. Middle : Contrasting the trajectory pairs to construct the memory. Right : Augmenting inference-time generation with retrieved memory.

Backbone	Method	Accuracy (%) $\uparrow$
		MATH500	GSM8K	MBPP	HumanEval	Average
Qwen-2.5-7B	Vanilla	$52.2$	$85.4$	$47.9$	$42.7$	$57.1$
	Buffer of Thoughts	$45.8$	$86.4$	57.6	$62.2$	$63.0$
	Dynamic Cheatsheet	$66.0$	$83.8$	$36.7$	$40.7$	$56.8$
	w/ Memory (7B)	$60.0$	$86.2$	$50.2$	$42.7$	$59.8$
	w/ Memory (32B)	$50.6$	$86.6$	$48.6$	$34.1$	$55.0$

Table 1: Performance of different memory methods with two models on math and code benchmarks.

Backbone	Method	Accuracy (%) $\uparrow$
		MATH500	GSM8K	MBPP	HumanEval	Average
Llama-3-8B	Vanilla	$27.4$	$73.0$	$37.0$	$29.3$	$41.7$
	Buffer of Thoughts	$20.6$	$73.6$	$43.2$	$34.2$	$42.9$
	Dynamic Cheatsheet	$29.4$	$71.2$	$27.2$	$17.1$	$36.2$
	w/ Memory (8B)	$29.2$	$63.2$	$47.1$	$42.7$	$45.6$
	w/ Memory (32B)	$18.8$	$56.6$	$35.8$	$34.1$	$36.3$

Table 2: Performance of Llama3-8B-Instruct– and Qwen2.5-32B-Instruct–based agents on mathematical reasoning and code benchmarks.

# Models	Qwen2.5-7B	Llama3-8B	Qwen2.5-32B
1	52.2	27.4	58.0
2	67.0	42.4	73.8
3	66.8	43.2	75.0

Table 3: Three-model collaboration on MATH500.

Figure 5: Task-category similarity of error-type distributions on MATH500.

Figure 6: Case study to compare the trajectories with and without the extracted memory guidance. Left : The contrasted trajectories pairs. Right : Changes in the agent’s output after incorporating the memory guidance. Note: all Key step and Issue are summarized, see full output is in Appendix D.7 .

Appendix figures & tables18 assets

Supplementary material from the paper’s appendix.

Appendix

Model	Method	MATH500	GSM8K	MBPP	HumanEval
Llama-3-70B	Vanilla	58.0	93.2	54.8	64.6
	w/ Memory (self)	59.6	93.5	56.3	68.6
	w/ MemCollab	65.2	93.6	63.0	74.4

Appendix

Table 4: Larger-scale cross-family collaboration with Llama-3-70B-Instruct.

Model	Vanilla	w/ Memory (self)	w/ MemCollab
Gemma3-4B	45.9	45.1	48.4
Qwen2.5-7B	47.9	50.2	50.8

Appendix

Table 5: Additional cross-family collaboration between Gemma3-4B-Instruct and Qwen2.5-7B-Instruct on MBPP.

Model	Setting	MATH500	GSM8K	MBPP	HumanEval
Qwen2.5-7B	Vanilla	52.2	85.4	47.9	42.7
	w/ Memory (self)	60.0	86.2	50.2	42.7
	w/ MemCollab	63.8	85.4	55.3	71.2
Llama-3-8B	Vanilla	27.4	73.0	37.0	29.3
	w/ Memory (self)	29.2	63.2	47.1	42.7
	w/ MemCollab	30.4	73.4	47.9	45.5

Appendix

Table 6: Comparable-scale cross-family collaboration between Qwen2.5-7B-Instruct and Llama-3-8B-Instruct.

Model	Setting	Accuracy
Llama-3-70B	Vanilla	54.8
	w/ Memory (self)	56.3
	w/ MemCollab	61.9
Qwen2.5-72B	Vanilla	59.9
	w/ Memory (self)	61.1
	w/ MemCollab	63.0

Appendix

Table 7: Large comparable-scale collaboration between Llama-3-70B and Qwen2.5-72B on MBPP.

Model	Method	Task Goal Completion				Scenario Goal Completion
Model	Method	Avg.	D1	D2	D3	Avg.	D1	D2	D3
GPT-5-nano	Vanilla	4.8	11.1	0.0	0.0	0.0	0.0	0.0	0.0
	MemCollab	26.7	44.4	26.7	0.0	10.0	0.0	20.0	0.0
GPT-5-mini	Vanilla	47.7	66.7	55.3	0.0	30.0	66.7	20.0	0.0
	MemCollab	63.3	66.7	66.7	50.0	50.0	66.7	40.0	50.0

Appendix

Table 8: Results on AppWorld. Task Goal Completion measures success on individual tasks, while Scenario Goal Completion is stricter and requires solving all variants within a scenario; D1–D3 denote increasing difficulty levels.

Model	Vanilla	w/ MemCollab
Qwen2.5-7B	15.4	21.3
Qwen2.5-32B	15.9	33.3

Appendix

Table 9: Performance comparison with and without MemCollab on open-ended task ASQA.

Method	MBPP
Vanilla	47.9
MemCollab (default)	57.6
MemCollab (random)	50.2
MemCollab (reverse)	52.9

Appendix

Table 10: Effect of preference selection on MBPP with Qwen2.5-7B.

Target Model	Summarizer	HumanEval
Vanilla	–	42.7
w/ MemCollab	Qwen2.5-32B	74.4
	Qwen2.5-7B	65.9
	Llama-3-8B	63.4

Appendix

Table 11: Effect of summarizer choice on HumanEval with Qwen2.5-7B as the target model.

Prompt Change	HumanEval
No memory	42.7
Original prompt	74.4
Add instruction to numbered list	74.4
Add instruction to JSON format	70.7

Appendix

Table 12: Prompt sensitivity on HumanEval.

Method	Wall Time (s)	Input Tokens	Output Tokens	Total Tokens
MemCollab	38.3	812.42	117.50	929.90
Self-Contrast	50.4	828.90	121.56	950.50
Self-Memory	13.35	499.02	63.78	562.80

Appendix

Table 13: Memory construction cost on MBPP using Qwen3-32B as the summarizer.

Dataset	Vanilla	MemCollab
MATH500	2.7	2.2
GSM8K	1.8	1.6
MBPP	3.1	1.4
HumanEval	3.3	1.5

Appendix

Table 14: Average number of reasoning turns for Qwen2.5-7B-Instruct based agent.

Method	MATH500	GSM8K	MBPP	HumanEval
Vanilla	$52.2\pm 0.40$	$85.4\pm 0.00$	$47.9\pm 3.37$	$42.7\pm 5.32$
w/ MemCollab	$\mathbf{67.0}\pm 0.42$	$\mathbf{87.4}\pm 0.31$	$\mathbf{57.6}\pm 0.90$	$\mathbf{74.4}\pm 3.52$

Appendix

Table 15: Mean performance and standard deviation over three random seeds.

Figure 7: Full trajectory used for memory summarization

Figure 8: Full trajectory of the memory-augmented inference

Source Question : Determine the range of parameters for which a triangle exists. Summarized Un-preferred Trajectory : Explicitly writes triangle inequalities and solves the feasible range. Summarized Preferred Trajectory : Uses the same inequality-based feasibility reasoning before computation. Memory Guidance : When determining geometric feasibility, enforce triangle inequalities by converting them into explicit inequality constraints before solving. Invariants : Translate geometric existence into inequality constraints. Variants : One sets equations first, then simplifies; the other simplifies before imposing constraints. Source Question : How many intersection points are formed by a given number of circles? Summarized Un-preferred Trajectory : Identifies all diagonal pairs and counts only those that intersect, rather than enumerating points directly. Summarized Preferred Trajectory : Counts all circle pairs using

\binom{n}{2}

and multiplies by the maximum possible intersections per pair. Memory Guidance : When dealing with combinatorial geometry problems involving intersections, enforce counting principles by first identifying all possible pairs of elements and then filtering based on intersection criteria; avoid direct enumeration without structured counting. When determining the probability of geometric events, enforce the calculation of favorable outcomes relative to total possible outcomes; avoid assuming uniform distribution without justification. Invariants : Decompose intersection problems into pairwise interactions with bounded intersection counts. Variants : One reasons at the geometric-object level (explicit intersection checks), while the other operates directly at the combinatorial level. One performs conditional filtering; the other applies a closed-form counting bound. Source Question :Determine a vector onto which multiple vectors have the same projection. Summarized Un-preferred Trajectory : Sets up dot-product equations equating scalar projections. Summarized Preferred Trajectory : Uses the same projection formula and explicitly enforces equality across vectors. Memory Guidance : When projecting multiple vectors onto the same vector and obtaining identical projections, enforce equality of scalar projection coefficients rather than treating each projection independently. Invariants : Equal projections imply a shared scalar projection constraint. Variants : One sets equations first, then simplifies; the other simplifies before imposing constraints.

Appendix

Table 16: Illustration of invariant reasoning patterns captured in the summarized memory entries.

Assistant Task 1. Core task summarization: Identify and describe the basic type and core challenges of the problem, such as classifying it as a mathematical problem (e.g., solving a quadratic equation), a data structure problem (e.g., array sorting), or an algorithmic problem (e.g., search algorithms). 2. Solution steps description: Outline the general solution steps, including how to define the problem, determine variables, list key equations or constraints, and choose appropriate solving strategies and methods. 3. General answer template: Based on the above analysis, propose a reusable template or approach that can be widely applied to this type of problem, including possible variables, functions, or class definitions. For programming problems, provide base classes or interfaces that can be instantiated to solve specific instances. Ensure the response is concise and structured so that instance-specific solutions can be generalized. Reusable Solution Skeleton 1. Define symbolic variables or core data structures. 2. Express the main constraints, equations, or problem conditions. 3. Convert the problem into a canonical or solvable form. 4. Apply the appropriate mathematical, algorithmic, or structural method. 5. Solve for the required variable(s) or compute the target quantity. 6. Verify or validate the result using the original constraints or expected outputs.

Appendix

Table 17: Prompt template for single-model reasoning extraction.

You are an expert analyst for extracting reusable REASONING MEMORY from contrastive multi-step mathematical reasoning trajectories. You are given multiple incorrect or partially correct reasoning traces or predicted outputs. Your goal is NOT to solve the problems. Your goal is NOT to correct the predictions. Your goal is to extract: 1) reusable failure-aware reasoning constraints, and 2) high-level reasoning strategies that characterize correct multi-step mathematical reasoning, expressed using abstract reasoning rules and high-level mathematical forms (rather than problem-specific calculations). Each extracted strategy must combine: - a trigger (when this strategy should be considered), and - an enforcement rule (what must be enforced or avoided). ANALYSIS SCOPE Analyze failures and near-misses at the reasoning level, focusing on: - explicit formalization of constraints and domains - correct construction and use of intermediate variables - alignment between mathematical structure and solution method - ordering of steps: formalize

\rightarrow

transform

\rightarrow

solve

\rightarrow

verify - separation between intermediate expressions and final solutions - handling of extraneous roots, boundary cases, and invalid domains Use high-level mathematical forms where appropriate, such as: - constraint systems:

\{f(x)=0,\ g(x)\geq 0\}

- canonical equations:

ax^{2}+bx+c=0

A\cdot x=b

- optimization conditions:

\nabla f(x)=0

- modular forms:

ax\equiv b\pmod{n}

- geometric invariants: distance, angle, or area relations Do NOT focus on: - surface arithmetic mistakes without structural impact - numerical simplification details - stylistic presentation or verbosity - producing corrected solution chains or final answers STRICT CONSTRAINTS - Each strategy MUST be grounded in an observable pattern across trajectories. - Do NOT introduce speculative or unverifiable strategies. - Strategies MUST be abstract and reusable across different mathematical domains. REQUIRED OUTPUT Each strategy MUST: - be written as one sentence - optionally reference high-level mathematical forms or invariants - follow this format exactly: When … , enforce … ; avoid … At least: - 1 strategy MUST describe failure-prevention or constraint enforcement - 1 strategy MUST describe high-level reasoning structure or invariants Do NOT: - include explanations - reference specific problems, constants, or numeric values - include worked examples or derivations - add any text before or after the list

Appendix

Table 18: Prompt template for contrastive extraction of reusable mathematical reasoning memory.

You are a mathematical problem classifier. Your task is to assign each math problem to exactly one subcategory within the given main category. You will be provided with: 1. The problem statement. 2. The main category (e.g., Algebra, Precalculus, Geometry, Number Theory). 3. A list of allowed subcategories for this category. Your output must be exactly one subcategory from the allowed list. CLASSIFICATION RULES 1. You MUST choose exactly one subcategory from the provided list. You may NOT output ‘‘None’’. You may NOT invent new categories. Only choose from the allowed subcategories provided. 2. If the problem clearly matches a subcategory definition, choose it, even if other superficial features appear. 3. If a problem fits multiple subcategories, choose the most specific one. 4. If a problem matches a special enforcement rule, you MUST apply that rule. These rules override all ambiguity. SPECIAL ENFORCEMENT RULES These rules override ambiguity and enforce consistent labeling: • Polar coordinates, polar--rectangular conversion, parametric coordinates

\rightarrow

Coordinate Systems . • Vector dot products, cross products, projections, vector angles, 3D line geometry

\rightarrow

Analytic Geometry (Vectors & Lines) . • Distance between points, midpoint, slope, basic coordinate geometry

\rightarrow

Analytic Geometry (Distance & Midpoints) . • Digit-restricted numbers or divisibility based on digit properties

\rightarrow

Modular Arithmetic & Digit Properties . • Proper divisors, prime factorization, number of divisors, GCD/LCM

\rightarrow

Divisibility & Prime Factorization . • Complex number rotation, geometric interpretation, roots of unity, transformations

\rightarrow

Complex Numbers (Geometry & Transformations) . • Equations involving radicals or exponentials (including logarithms)

\rightarrow

Radical & Exponential Equations . Exception: Compound interest or exponential growth/decay word problems

\rightarrow

Exponential & Logarithmic Equations . • Counting or arrangement problems with restrictions (e.g., adjacency constraints)

\rightarrow

Combinatorial Argument & Constraints . • Constructing polynomials from values or missing coefficients

\rightarrow

Polynomial Interpolation . • Equations involving functional constraints (e.g.,

f(x+y)

, invariance)

\rightarrow

Functional Equations . OUTPUT FORMAT Your response must be ONLY the name of the chosen subcategory. No explanations. No justification. No additional text. INPUT FORMAT Problem: {PROBLEM} Main Category: {CATEGORY} Allowed Subcategories: {SUBCATEGORY_LIST} YOUR TASK Select exactly one subcategory from the list.

Appendix

Table 19: Prompt template for task classification used in task-aware retrieval.

Memory-Augmented Language Model Agents

Memory-augmented language model agents use persistent facts, interaction histories, and skills to support personalization and long-horizon tasks.

See all 428 papers

Aug 31, 2026

Learning What to Retain: Gated-Memory Routing for Efficient Collaboration in Multi-Agent LLM Systems

Large language model (LLM)-based multi-agent systems tackle complex reasoning by orchestrating how multiple agents are configured and how they collaborate. A central challenge is to adapt orchestration to the evolving collaboration state. Routing from the query alone cannot adapt to intermediate progress or errors, which hurts accuracy. Routing from the complete execution history supplies this missing context, but forces later decisions to process every prior step, including redundant or low-utility ones. This creates an execution-history overload that inflates cost. Effective orchestration instead requires a compact state that captures useful progress without accumulating redundant context. We propose Gated-Memory Routing, which conditions each decision on the query and a learned execution memory. A learned Memory Write Gate commits only non-redundant reasoning steps, and a learned Retrieval Gate supplies each agent a compact, relevant subset, so every decision conditions on a clean, informative state. At each step, the system selects the next role and backbone from this memory, while an Adaptive Halting Controller stops execution once the memory contains sufficient evidence for answering. Across five reasoning and code-generation benchmarks, our framework is both effective and efficient: it attains the best average accuracy, exceeding the strongest baseline by 2.44 points, while reducing HumanEval inference cost by 31.9% relative to that baseline. Code is available at https://github.com/rajibrhasan/gated-memory-routing

Rakibul Hasan Rajib, Mengxin Zheng, Qian Lou

University of Central Florida

Multi-Agent LLM Systems Multi-Agent System Optimization LLM Agent Orchestration LLM Agent Workflow Optimization LLM Agents LLM Routing+1

Ask PDF

Oct 9, 2026

Collaborative Learning and Reasoning over Model Slices

Large language models (LLMs) excel across diverse tasks, benefiting from knowledge priors, in-context reasoning, and test-time computation. Despite these strengths, single-model reasoning remains vulnerable to error propagation, as later steps depend on the model's earlier outputs, leaving reasoning blind spots difficult to independently reassess. To address this limitation, we develop collaborative learning, encompassing the construction of heterogeneous collaborators and the learning of effective cross-model collaboration. Specifically, model slicing replaces a large model with smaller, heterogeneous models under a comparable parameter budget, enabling prior reasoning to be reassessed across distinct model parameterizations. Pyramid supervision combines protocol distillation with step-level supervision to refine reasoning and interaction decisions throughout collaboration. We evaluate our approach across four task categories: multi-hop question answering, mathematical reasoning, code generation, and open-ended constrained generation. The trained heterogeneous models achieve comparable or better task performance than the original large model and established multi-agent baselines, including reinforcement-learning-based methods, while also achieving higher inference efficiency than the multi-agent baselines and exhibiting differentiated collaboration patterns across tasks. These findings show that learned collaboration turns model heterogeneity into complementary reasoning capabilities.

Yuheng Wang, Runde Yang, Zhuohan Bao +9

School of Artificial Intelligence, Shanghai Jiao Tong University

Multi-LLM Collaboration Multi-Agent Reasoning Efficient Language Model Reasoning

Ask PDF

Oct 5, 2026

MemCo: Memory-Centric Collaboration for Generalizing LLM Agents to Unseen Environments

Large language model (LLM) agents increasingly operate in interactive environments, where they need to make sequential decisions through observation, action, and feedback. Although memory can help agents reuse experience, existing work designs memory in isolation, where collecting enough trajectories to populate it is expensive. Existing shared-memory approaches mitigate isolated experience by pooling episodic memories across tasks and environments. However, retrieving shared memory is challenged by the granularity, where retrieved memories can be either too specific to preserve current grounding or too coarse to support the next action. In this work, we propose MemCo, a memory-centric collaboration framework for generalizing LLM agents to unseen interactive environments. It maintains complementary local and global memory spaces, preserving environment-specific details locally while promoting transferable workflows induced from local trajectories to global memory. During online interaction, MemCo routes relevant local and global memories in terms of the agent's current state and decision phase, enabling agents to reuse the experience of other agents without blindly transferring environment-specific details. Experiments on interactive decision-making benchmarks show that MemCo improves task success and reduces redundant exploration compared with isolate-memory and shared-memory baselines. Our code is available at https://github.com/SYannL/nvdamas.

Xinting Liao, Siyan Liu, Rabab K. Ward +2

The University of British Columbia, Vancouver, BC, Canada · Vector Institute, Toronto, ON, Canada · NVIDIA, Santa Clara, CA, USA

Memory-Augmented Language Model Agents Shared-Memory Multi-Agent Systems Multi-Agent LLM Systems

Ask PDF

Abstract

Memory-Augmented Language Model Agents

Explore similar work

Learning What to Retain: Gated-Memory Routing for Efficient Collaboration in Multi-Agent LLM Systems

Collaborative Learning and Reasoning over Model Slices

MemCo: Memory-Centric Collaboration for Generalizing LLM Agents to Unseen Environments