acceptodds
Withdrawn from ICLR 2027

MACE: Memory-Agent Co-Evolution with Adaptive Memory Graphs for Multi-Agent Systems

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

Abstract

LLM based multiagent systems (MAS) accumulate collaboration experience through task execution, including task conditions, agent actions, intermediate artifacts, repairs, and outcomes (Wu et al., 2023). Reusing this experience can improve later collaboration, yet existing memory mechanisms often treat experience as isolated records or static graph context. They therefore miss two requirements of multiagent reuse. The first is functional structure, because a useful experience depends on how conditions, actions, and outcomes support one another and how this support extends across experiences. The second is adaptive use, because the same memory unit may need different selection, format, placement, and strength for different agents and execution states. We propose MACE, a memory agent co evolution framework that jointly organizes experience and learns how agents should use it. MACE introduces MemGoG, which stores experience as functional graph units with typed links across units. It then uses a Need Aware Memory Composer to build a compact working graph, an Adaptive Agent Memory Coupler to render role specific memory patches, and a Feedback Co Evolver to update unit utility, graph links, and agent side use policies after execution. Across eight benchmarks, MACE achieves an average score of 81.11%, improving over the strongest controlled baseline by 2.14%.

Primary area:
foundation or frontier models, including LLMs
Keywords:
Multi-Agent Systems, Graph-Structured Memory, Adaptive Memory Composition, Memory-Agent Co-Evolution, Large Language Models

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_kcgiOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes MACE, a memory-agent co-evolution framework for improving historical experience reuse in multi-agent systems. MACE introduces a graph-based memory representation to capture functional dependencies across experiences, along with adaptive memory composition, agent-specific memory coupling, and feedback-driven updates.

Critical strengths
  1. The paper addresses an important problem of effectively reusing historical collaboration experiences in multi-agent systems

  2. The proposed framework has a clear modular design, with separate components for memory construction, composition, agent-specific coupling, and feedback-based updates

Critical weaknesses
  1. Limited Validation of Memory-Agent Co-Evolution. Although memory-agent co-evolution is the main contribution of MACE, the experiments in Section 6 use frozen memory graphs and agent-side policies, with execution feedback recorded but not used to update subsequent evaluations. Therefore, the reported performance improvements primarily demonstrate the effectiveness of memory composition and agent-specific coupling, rather than continuous co-evolution.

  2. Misalignment between Benchmarks and Research problems. Most of the selected benchmarks are reasoning-oriented tasks, including question answering, mathematical reasoning, which can typically be solved without multi-agent coordination or persistent agent memory. Therefore, these benchmarks seemingly provide limited evidence of the effectiveness of MACE in scenarios that genuinely require collaborative experience reuse and memory-agent co-evolution.

  3. High Cost but Limited Performance Gains. As shown in Table 3, MACE requires substantially more computational resources than the baselines. Its computational cost is approximately 11 times that of Direct, but achieving only a 2.14% improvement over the strongest baseline SAGE. The high computational cost and latency raise concerns about the practical effectiveness and efficiency of MACE.

  4. Insufficient Clarity of the Empirical Study. The empirical study in Section 4 lacks sufficient details. In particular, the two memory composition strategies (C1 and C2) are only briefly described as task-matching and supporting strategies. However, the paper does not clearly explain how supporting memory units are identified and selected, or how the two strategies operate. Similarly, the Guide and Checklist formats are not concretely defined or illustrated.

Questions for authors
  1. How are the functional memory units and typed relations in MemGoG constructed in practice? How is the correctness of the constructed relations ensured?
  2. How is the credit vector in Eq.12 determined when multiple memory units contribute to a task? In particular, how does MACE distinguish genuinely useful memory units from those that are retrieved but have little influence on the final outcome?

Some other concerns listed in weakness part

Reviewer_wGP1OpenReview ↗
Rating
1
Confidence
2
Informativeness
2
Presentation
1
Soundness
1
Read review
Paper summary

A collaboration experience from the paper is considered to consist of task conditions, agent actions, intermediate artifacts, repairs, and outcomes. The authors explore how this experience could be reused to improve future collaboration, with a focus on memory design. The memory is designed with two principles: 1) functional structure with MemGoG to support the relationship of conditions, actions, and outcomes for within- and across-experience interpretation; and 2) adaptive use, which essentially gathers relevant information by building and retrieving from a working graph. The proposed MACE framework jointly organizes experience and learns how agents should use it via MemGoG, Need Aware Memory Composer, Adaptive Agent Memory Coupler, and Feedback Co Evolver. The experiments are done on 8 benchmarks with improved results over the baselines.

Critical strengths
  1. The topic of memory design for collaborative multi-agent systems is timely, and the experimental design with 4 research questions across 8 benchmarks is generally thoughtful.
Critical weaknesses
  1. It seems that many mathematical objects are introduced in the methodology section, but how they operate in the system and interact with other objects remains unclear. Further, it remains unclear what the sources of objects are: which come from LLM agents and which come from the system/environment. I think MACE, as a system, can greatly benefit from more clear explanations of the section to also justify MACE's performance improvements. Some parts I found a bit hard to follow:
  • a. The MEMGoG operates on a “need descriptor” that specifies the “task, role, stage, current state, requested memory function, and available budget.” The MEMGoG is a graph that contains “type, function, trigger set, output, utility, and source record.”
  • b. The relation set contains “support, abstraction, operationalization, role projection, conflict, repair, and feedback links.”
  • c. The Composer scores by “normalized task fit, utility, and support,” as well as “normalized conflict, cost, and risk.” How is each scored? Is there a trained model, or is it just by agents?
  • d. The Coupler gathers “selected content, source records, support links, and routine links” and converts it into a patch configuration, including “content, mode, format, timing, strength, placement, and source records.”
  • e. Each agent’s state concerns its role and stage, which includes “preferred unit types, format, timing, strength, and placement.”
  1. Regarding collaboration, in Section 2 the authors hint at the use of collaboration workflows. Are there comparisons across workflows, since different collaboration workflows could assign agents different roles? Also, would MACE allow dynamic workflows?
Questions for authors
  1. Regarding the first weakness, it would greatly help if there were something like an annotated trace or examples of each component, how they are defined and constrained, and how they operate alongside other components. This could help motivate the purpose and necessity of each component.
  2. Could the authors also explain Figure 5 in more detail, including the setting for dynamic interaction and online adaptation?
Reviewer_k65uOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper proposes MACE, a method for reusing past experience in LLM multi-agent systems. It organizes past trajectories into functional memory units and connects them with different types of relations. For a new task, the system retrieves relevant memory units and uses a coupling module to convert them into patches for different agent roles. The memory is then updated based on execution feedback, including how useful each unit is and which patches tend to work better. The approach does not require updating the agent model weights.

The evaluation covers eight benchmarks, with additional experiments on memory organization, ablations, robustness, and online adaptation. MACE reports an average score of 81.11%, which is 2.14%+ better than the strongest controlled baseline of SAGE.

Critical strengths
  • I like the observation that memory selection and memory presentation should be considered together. The composition-by-format experiment in section 4 is more interesting to me than the overall benchmark ranking. A memory composition that works well as a guide can work poorly as a checklist. This gives a concrete reason to optimize how agents receives memory instead of simply improving retrieval.

  • The reported gains cover several task types, and the paper makes some effort to check them beyond the main single-run table. In particular, Appendix D4 reports paired comparisons with positive confidence intervals on MMLU-Pro, LiveCodeBench, and TAT-QA. The online-vs-frozen comparison is also relevant to the proposed feedback mechanisms. These are useful evidence, although the experimental details need improvement.

Critical weaknesses

The central mechanism is still too underspecified. Section 5 introduces many quantities, but I could not figure out precisely how the agent-side use policy is learned. How are format, timing, strength, and placement selected and updated? How is credit divided among used memory units? The algorithms in appendix mostly replaced these decisions with function names. The historical memory sources and calibration sizes for the eight main benchmarks are also not clearly documented. Freezing memory during testing is a good precaution, but it does not tell us what went into that memory before testing. These details are central to both reproducibility and judging the contribution of this work.

Questions for authors
  • What exact data and how many trajectories were used to initialize and calibrate memory for each main benchmark? Were the same source experiences available to all memory baselines, and how did you check overlap with evaluation instances?

  • Can you provide the actual selection and update rules for the agent-side patch policy, such as credit assignment and the relevant hyperparameters? Also, how does the four-call implementation in Appendix E.1 map onto the agent roles listed in Appendix H?

  • Please explain the direct degradation under retrieval noises and MMLU ablation percentage mentioned above. Do these tables use a different protocol or denominator from the stated one?

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

Related papers

Discussion (0)

Sign in to comment.