acceptodds
Under review as a conference paper at ICLR 2027

MASFACT: Continual Multi-Agent Topology Learning via Geometry-Aware Posterior Transfer

Abstract

Multi-agent systems (MAS) powered by large language models (LLMs) have emerged as a powerful paradigm for complex problem solving, where performance critically depends on the underlying inter-agent communication topology. However, existing topology generation methods mainly optimize for isolated tasks, while real-world deployments involve streams of evolving tasks, requiring previously effective collaboration patterns to be retained and reused rather than rediscovered or overwritten. We identify a previously underexplored failure mode, topology forgetting, in which adapting to new tasks shifts the topology generator away from communication structures required by earlier tasks. This issue stems from cross-task misalignment in both agent-level functional semantics and relational communication structures. To address this challenge, we propose MASFACT, a geometry-aware posterior transfer framework that preserves and reuses historical collaboration knowledge as transferable topology priors. We transfer these priors across task-specific agent spaces through Fused Gromov-Wasserstein optimal transport and perform PAC-Bayes-guided conservative posterior adaptation to balance task-specific plasticity with structural stability. Experiments across class-, domain-, and task-level continual settings demonstrate that MASFACT consistently improves average accuracy while reducing topology forgetting compared to strong topology generation and replay-based baselines, and can be seamlessly integrated with different MAS topology generators.

Primary area:
learning on graphs and other geometries & topologies
Keywords:
Multi-Agent Systems, Large Language Models, Continual Learning, Topology Learning, Graph Optimal Transport

Reviews

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

This paper proposes MASFACT, which adds a library of historical structures to existing methods for generating multi-agent graphs. It retrieves and aligns historical structures based on agent attributes and connections, then uses a small number of samples from the new task to adjust the connections while limiting the magnitude of the changes. The algorithm updates the structure library with effective new structures.

Critical strengths
  1. It improves performance across multiple graph-construction methods. Table 4 shows that after integrating MASFACT, AGP, GDesigner, and ARGDesigner all achieve higher average accuracy and less forgetting in experiments involving successive changes in question categories, datasets, and task types.

  2. Preserving historical collaboration structures and continuing to adapt and reuse them as new tasks arrive is a practically meaningful direction. This paper offers an approach to accumulating and using experience from past collaborations in continually learning multi-agent systems.

Critical weaknesses
  1. The additional benefits of the structure library over the original graph-construction policy remain unclear

    Methods such as GDesigner already learn graph-construction policies from training tasks, retaining training experience in the controller parameters. The authors adapt these baselines into versions that update stage by stage as tasks arrive, but do not report their performance when they stop updating after base-stage training and directly handle subsequent tasks. Fixing the network parameters does not mean using the same graph for every question, so comparisons with fixed chains, trees, and historical graph reuse cannot replace this result. Without this comparison, it remains difficult to determine how much continual adaptation adds over directly using the existing policy.

    The authors also need to explain whether the original graph constructor continues to be updated after integrating MASFACT, and whether its update procedure remains consistent with that of the baseline algorithm. Although Table 5 reports a performance drop after removing the historical prior, it does not explain which graph-construction and training steps this version retains. If different versions update different parameters, the differences in forgetting may not come solely from the structure library.

  2. Key steps in training and old-task testing are not clearly described

    The paper does not explain how feedback from actual problem solving is used to update the connection parameters. The differentiable sampling in the paper handles discrete edge selection, but feedback such as answer correctness and code test results cannot be differentiated directly. The authors need to explain how the parameters are updated using this feedback. The paper states that parameters are not updated during old-task testing, but does not specify which set of connection-adjustment parameters is used. Does testing directly use the latest parameters after learning new tasks, or does it also use parameters saved separately for old tasks? These choices affect old-task performance and the assessment of forgetting.

Questions for authors
  1. Does the original graph constructor continue to be trained after integrating MASFACT? Which parameters are updated in the full method and in the version without the historical prior in Table 5? Apart from the historical prior, what other differences are there in the graph-construction and training steps of these two versions?

  2. How is actual problem-solving feedback, such as answer correctness and code test results, used to update the connection parameters? Beyond differentiable edge sampling, what parameter-update method is used?

  3. After learning new tasks, which set of connection-adjustment parameters is used when testing old tasks? Are parameters saved separately for each old task?

5 comments

Thank you! We would be glad to provide further details upon request.

W1-1: Continual Adaptation Versus a Frozen Dynamic Graph Policy

To assess whether the graph constructor’s base-stage experience is sufficient for subsequent tasks, we compare frozen graph construction, continual constructor updates, and MASFACT, evaluating both new-task learning and old-task retention.

  • Shared settings: All methods use the same Llama-3.1-8B-Instruct, GDesigner-based MAS, base-stage initialization, data splits, and evaluation execution budgets. The three streams are task-level (KQA→Math→Code→MQA), Code domain-level (APPS→HumanEval→LiveCodeBench→MBPP), and the 13-stage class-level (MMLU-Pro).
  • Constructor baselines: The frozen policy keeps its parameters fixed while generating input-dependent communication graphs. Continual-update variants train the constructor at each stage using 10 support examples or, in the standard setting, up to 2,000 distinct training examples.
  • MASFACT: The constructor remains frozen after the base stage. Current support feedback optimizes the connection residual and determines which adapted structures update the prior bank.
  • Table A reports final AA and AF, while Tables B–D report held-out accuracy immediately after each new stage. AA averages accuracy equally across all seen tasks, and AF measures average old-task degradation from each task’s best previous performance. New-stage means exclude the base stage. Results are means and standard deviations over five paired random seeds.
  • Within each data setting, adaptive methods use the same support examples, number of optimization steps, and training execution budget.

Table A. AA and AF across three continual-learning levels

MethodTask-level AA ↑Task-level AF ↓Domain-level: Code AA ↑Domain-level: Code AF ↓Class-level: MMLU-Pro AA ↑Class-level: MMLU-Pro AF ↓
GDesigner, frozen44.53 ± 0.260.00 ± 0.0056.23 ± 0.340.00 ± 0.0042.19 ± 0.510.00 ± 0.00
GDesigner, 10-shot41.81 ± 0.176.95 ± 0.0854.46 ± 0.174.89 ± 0.1141.67 ± 0.512.34 ± 0.19
GDesigner, standard43.63 ± 0.167.12 ± 0.1254.23 ± 0.647.51 ± 0.1343.23 ± 0.473.01 ± 0.16
MASFACT, 10-shot51.67 ± 0.102.07 ± 0.0661.14 ± 0.12−2.03 ± 0.0646.93 ± 0.14−0.78 ± 0.27
MASFACT, standard54.01 ± 0.362.40 ± 0.0263.48 ± 0.26−1.70 ± 0.0649.28 ± 0.52−0.45 ± 0.29

Table B. Task-level new-stage accuracy (%).

Sequence: KQA → Math → Code → MQA. Base stage: KQA.

MethodMathCodeMQA
GDesigner, frozen36.04 ± 0.7649.24 ± 0.5041.58 ± 0.65
GDesigner, 10-shot39.26 ± 0.3652.40 ± 0.5143.95 ± 0.77
GDesigner, standard41.30 ± 0.2157.08 ± 0.4144.62 ± 0.19
MASFACT, 10-shot48.43 ± 0.3664.95 ± 0.4947.21 ± 0.46
MASFACT, standard51.19 ± 0.3166.58 ± 0.5853.41 ± 0.24

Table C. Code domain-level new-stage accuracy (%).

Sequence: APPS → HumanEval → LiveCodeBench → MBPP.

Base stage: APPS.

MethodHumanEvalLiveCodeBenchMBPP
GDesigner, frozen66.17 ± 0.4634.43 ± 0.1964.83 ± 0.37
GDesigner, 10-shot68.73 ± 0.3336.91 ± 0.2965.78 ± 0.21
GDesigner, standard72.86 ± 0.3240.37 ± 0.1866.72 ± 0.26
MASFACT, 10-shot70.87 ± 0.2339.64 ± 0.1267.26 ± 0.27
MASFACT, standard75.29 ± 0.1843.47 ± 0.2568.94 ± 0.19

(Due to the character limit, our response to W1-1 continues in the next comment.)

(This comment continues our previous response to W1-1.)

Table D. MMLU-Pro new-stage accuracy (%).

Base stage: Physics.

MethodChemistryBiologyMathematicsComputer ScienceHealthEngineeringBusinessLawEconomicsPsychologyHistoryPhilosophy
GDesigner, frozen42.23 ± 0.7254.18 ± 0.3930.14 ± 0.2642.81 ± 0.7548.25 ± 0.1930.87 ± 0.4845.06 ± 0.6228.37 ± 0.3642.42 ± 0.7455.15 ± 0.9347.12 ± 0.8545.20 ± 0.51
GDesigner, 10-shot42.93 ± 0.3654.60 ± 0.8331.31 ± 0.7443.82 ± 0.8149.22 ± 0.4632.08 ± 0.5346.15 ± 0.2628.64 ± 0.4142.57 ± 0.5656.25 ± 0.1748.17 ± 0.4945.27 ± 0.32
GDesigner, standard45.13 ± 0.7656.38 ± 0.6435.09 ± 0.9546.96 ± 0.8250.40 ± 0.5934.96 ± 0.7448.29 ± 0.5031.24 ± 0.2744.08 ± 0.4557.27 ± 0.3150.42 ± 0.5449.35 ± 0.49
MASFACT, 10-shot45.15 ± 0.1256.28 ± 0.3534.88 ± 0.2347.19 ± 0.7950.83 ± 0.5336.16 ± 0.4148.31 ± 0.4829.81 ± 0.3244.97 ± 0.4457.88 ± 0.5651.06 ± 0.3749.04 ± 0.50
MASFACT, standard48.27 ± 0.4759.16 ± 0.5838.44 ± 0.3650.11 ± 0.5253.37 ± 0.4338.58 ± 0.6151.35 ± 0.4033.53 ± 0.5547.47 ± 0.4960.46 ± 0.3453.41 ± 0.5752.43 ± 0.45

The experimental findings are as follows:

  1. The frozen dynamic policy preserves old-task performance but provides insufficient adaptation to new tasks. Its mean new-stage accuracy falls below few-shot MASFACT by 11.24%, 4.11%, and 3.31% at the task, domain, and class levels, respectively. Although the frozen constructor generates input-dependent graphs, its construction rules receive no subsequent task feedback.

  2. Continual constructor updates improve new-task learning but introduce forgetting. On the task stream, mean new-stage accuracy reaches 45.20% with few-shot updates and 47.67% with standard updates. The latter incurs 7.12 AF, illustrating the retention cost of adapting the constructor to subsequent tasks.

  3. MASFACT achieves a better adaptation–retention balance than continual constructor training. Relative to few-shot GDesigner, it improves task-level AA by 9.86 percentage points and reduces AF by 4.88 percentage points, with higher AA and lower AF across all three levels. Aligned historical references guide adaptation, while constrained residual updates adjust communication paths using current feedback.

  4. Historical reuse enables effective continual adaptation with limited new-task feedback. Few-shot MASFACT exceeds standard GDesigner’s final AA by 8.04, 6.91, and 3.70 percentage points across the three levels. By reusing collaboration experience and updating connection residuals, MASFACT supports adaptation after deployment without repeatedly retraining the original constructor.

W1-2 & Q1: Constructor Updates and Baseline Adaptation Protocols

  1. After integrating MASFACT, the original graph constructor is frozen after base-stage training. Incremental stages optimize only connection residuals and selectively update the prior bank. The frozen constructor generates a task-dependent scaffold for historical-prior retrieval and alignment to the current agent space. Residual editing around the aligned prior center then produces the executable communication graph.

  2. All MASFACT-integrated optimizers in Table 4 (AGP, GDesigner, and ARGDesigner) follow this same freezing and adaptation protocol. Each method first learns or optimizes its topology-construction components on sufficient base-stage data according to its original protocol. These components are then fixed, while the MASFACT's historical-prior retrieval, alignment, and residual-adaptation pipeline handles subsequent tasks. Table 4 shows that structural prior guided residual adaptation enhances continual learning across different topology-construction methods. (Table 4, Appendix G.2)

  3. The standalone baselines in Tables 1–3 retain their original optimization targets and objectives, using current-stage support under a shared continual-learning protocol. Variants marked with † are replay-based baselines. For each old task, replay variants adapt the model using historical training examples from that domain, then evaluate its performance on that domain. MASFACT uses structural memory without replaying raw historical examples, and the results support a better overall accuracy–forgetting trade-off. (Tables 1–3, Appendices F.2–F.3)

MASFACT-integrated methods therefore share a frozen-constructor protocol, while standalone baselines retain their respective adaptation mechanisms, with continual-learning benefits assessed against both standalone and replay-enhanced alternatives.

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

This paper studies topology forgetting in LLM-based multi-agent systems. The LLM agents remain fixed, while the communication topology is updated across a sequence of tasks. MASFACT stores useful historical topologies as prior atoms, aligns them to the current agents using Fused Gromov–Wasserstein transport, and learns sparse residual changes with a KL constraint.

LLM-based multi-agent topology learning is outside my primary area of expertise. I may therefore not be able to assess all technical aspects of this submission reliably, and I have informed the AC of this expertise mismatch. Accordingly, my confidence is 1.

Critical strengths
  1. The method has a clear structure. The prior bank stores historical topologies, FGW aligns different agent spaces, and residual adaptation balances reuse and new-task learning.

  2. The evaluation covers several settings. The paper includes class-, domain-, and task-level continual learning across multiple reasoning datasets.

  3. The paper provides useful analysis. It includes component ablations, simpler topology-reuse methods, task-order tests, memory comparisons, and a topology-only intervention.

Critical weaknesses
  1. The configuration behind the main MASFACT results is unclear. Section 4.1 says that the experiments use a GDesigner-style backbone. However, the “MASFACT” results in Tables 1–2 differ from “GDesigner + MASFACT” in Table 4 under apparently identical settings. For example, the MMLU-Pro results are 49.18 / −0.19 and 47.93 / 0.79. Which configuration produced the main MASFACT results, and why are these numbers different?

  2. The generalization claim is limited. All experiments use Llama-3.1-8B-Instruct with fixed agent capabilities. The three backbones in Table 4 are topology optimizers, not different LLMs. The results show compatibility with different topology optimizers, but not generalization across LLM backbones or changing agent capabilities. Please test another LLM or narrow the claim.

Questions for authors

see weaknesses

6 comments

Thank you! We would be glad to provide further details upon request.

W1: Main-Experiment Configuration and the Discrepancy with Table 4

  1. The only configuration difference between MASFACT in Table 1-3 and GDesigner + MASFACT in Table 4 is the graph representation used during historical-prior retrieval and FGW alignment.
  • Table 1-3 reads the weighted candidate graph from within GDesigner’s topology generator, retaining continuous edge probabilities.
  • The corresponding GDesigner integration in Table 4 instead uses its discrete output graph as the scaffold.
  • These experiments evaluate the complete method across task-, domain-, and class-level continual-learning streams.
  1. Table 4 tests whether MASFACT can enhance existing MAS systems through their topology generators’ output interfaces.
  • For this deployment-oriented integration, we represent the discrete outputs of AGP, GDesigner, and ARGDesigner as binary scaffolds for historical retrieval and alignment. MASFACT then adapts the resulting aligned historical prior through connection residuals.
  • Table 4 evaluates integration through existing generators’ graph-output interfaces. MASFACT retains the original constructor and agent execution framework, uses the generated graph as a scaffold, and supplies its adapted posterior graph to the original executor. Each generator is compared with its own MASFACT-integrated version under matched evaluation conditions. (Appendix G.2.1–G.2.2)
  • Table 4 shows that MASFACT can serve as a plug-and-play topology optimization, enhancing the continual learning capabilities of already deployed MAS without altering their underlying mechanisms.
  1. On MMLU-Pro, weighted scaffolds yield 49.18 AA and −0.19 AF, while discrete scaffolds yield 47.93 AA and 0.79 AF.
  • Continuous edge probabilities retain distinctions removed by binarization. These values enter FGW’s relational cost, so changing their representation can alter node correspondences, prior selection, and the adapted posterior graph. (Eqs. 4–7)
  1. Table 4 reports higher AA and lower AF after integrating MASFACT with each topology generator.
  • This supports its compatibility with different topology optimizers through their graph-output interfaces.

W2: Generalization Across LLM Backbones and Changing Agent Capabilities

To address your concern about generalization, we provide additional empirical evidence through experiments with another LLM backbone and controlled changes to agent configurations midway through continual learning.

1. Agent capabilities varying with task types and domain characteristics: The current experiments cover continual learning with different agent functional configurations.

  • Our task- and domain-level experiments use task-specific roles, prompt templates, tool scripts, and agent configuration schemes. Mathematics task emphasizes decomposition, computation, and checking, Code emphasizes programming, testing, and repair, Knowledge QA emphasizes specialist analysis and answer verification, and Multi-hop QA emphasizes evidence retrieval and aggregation. (Sec. 4.1, Appendices E and F.5)

  • Existing experiments have already validated performance under “changing agent capabilities” and demonstrated MASFACT's effectiveness. In the task-level sequence “Knowledge QA → Math → Code → Multi-hop QA”, where transitions also change task-specific agent roles, instructions, and tool use, MASFACT achieves 51.67% AA and 2.07% AF (+6.17% AA ↑, −5.41% AF ↓ over MasRouter, Tables 2 and 11), supporting continual adaptation under task-related functional changes.

The following experiments additionally examine LLM replacement and midstream configuration changes within fixed task sequences.

2. Generalization across LLM backbones.

  • We evaluate MASFACT with Qwen3.5-9B across three continual-learning levels to test its effectiveness on another LLM backbone. The experiments cover the task-level sequence KQA→Math→Code→MQA, the Math and Multi-hop QA domain-level streams, and the class-level MMLU-Pro and TACO streams with 13 and 8 stages, respectively.
  • We compare MasRouter, ARGDesigner, and MASFACT using Qwen3.5-9B as the fixed agent LLM. Each method trains its routing or graph-construction policy during the base stage and follows its adaptation procedure using 10 support examples per subsequent stage. Data splits and execution budgets are matched, with Qwen’s non-thinking mode fixed throughout. Results report means and standard deviations over five paired seeds.

Table A. Qwen3.5-9B: task- and domain-level continual learning.

StreamMethodAA ↑AF ↓
Task: KQA→Math→Code→MQAMasRouter68.42 ± 0.632.58 ± 0.11
ARGDesigner69.51 ± 0.782.19 ± 0.13
MASFACT72.05 ± 0.420.68 ± 0.07
Domain: MathMasRouter74.69 ± 0.721.45 ± 0.14
ARGDesigner72.48 ± 0.811.35 ± 0.07
MASFACT76.61 ± 0.580.23 ± 0.09
Domain: Multi-hop QAMasRouter67.28 ± 0.641.53 ± 0.06
ARGDesigner67.93 ± 0.711.68 ± 0.09
MASFACT70.38 ± 0.570.19 ± 0.06

Table B. Qwen3.5-9B: class-level continual learning.

StreamMethodAA ↑AF ↓
MMLU-Pro, 13 stagesMasRouter74.18 ± 0.571.39 ± 0.12
ARGDesigner72.15 ± 0.620.94 ± 0.14
MASFACT79.12 ± 0.430.24 ± 0.03
TACO, 8 stagesMasRouter76.08 ± 0.621.98 ± 0.27
ARGDesigner78.73 ± 0.822.24 ± 0.32
MASFACT79.40 ± 0.530.49 ± 0.14

The experimental findings are as follows:

  • MASFACT achieves the highest AA and lowest AF across all five Qwen3.5-9B streams, supporting effectiveness beyond the original LLM backbone. Across the three continual-learning levels, it improves AA by 0.67% to 4.94% over the highest-AA baseline and reduces AF by 0.70% to 1.51% relative to the lowest-AF baseline in each stream.

  • Baseline forgetting varies across backbones, and MASFACT provides additional retention benefits on Qwen3.5-9B. On the cross-task sequence, MasRouter’s AF decreases from 7.48% with Llama to 2.58% with Qwen, while MASFACT achieves 0.68% on Qwen. We will add complete results across all three continual-learning levels and all evaluated benchmarks to the revised appendix.

(Due to the character limit, our response to W2 continues in the next comment.)

(This comment continues our previous response to W2.)

3. Generalization under changing agent capabilities

We switch to an AgentVerse-derived [1] agent configuration midway through continual learning. Both configurations retain five collaboration nodes and the same final-answer aggregation procedure, covering the same tasks but using different expert instructions, tool permissions, and feedback handling. Communication paths remain controlled by each evaluated method, with the underlying LLM and execution budgets fixed.

  • Switches occur at the midstream positions. We switch before Stage 3 Code in the task-level sequence, Stage 3 MuSiQue in the Multi-hop question domain-level sequence, and Stage 5 Greedy algorithms in the TACO class-level sequence.

  • Switch and no-switch branches share the same pre-switch state. For each method, the two branches share examples and seeds. SWITCH replaces agent configurations and refreshes node capability attributes. MASFACT retains its prior bank and saved task residuals, refreshes agent attributes, and continues adaptation using the current support set. Both baselines use the same support examples through their original optimization procedures.

  • For each fixed LLM backbone, the routing or topology-learning policy is trained during the data-rich base stage and adapted using 10 support examples per subsequent stage. LLM weights remain fixed throughout. We use five paired seeds with matched data splits, stage orders, support examples, and execution budgets.

  • Final AA and AF jointly measure overall performance and old-task retention. After completing the sequence, AA equally averages evaluation accuracy across all seen tasks. AF compares each earlier task’s final accuracy under the current configuration with its best accuracy at previous stages, including stages before the switch.

In Tables C–E, Llama denotes Llama-3.1-8B-Instruct and Qwen denotes Qwen3.5-9B. All results are mean ± standard deviation over five paired seeds.

Table C. Task-level: KQA→Math→Code→MQA. Switch before Stage 3 Code.

LLMAgent capabilitiesMasRouter AA ↑MasRouter AF ↓ARGDesigner AA ↑ARGDesigner AF ↓MASFACT AA ↑MASFACT AF ↓
LlamaSWITCH41.98 ± 0.519.92 ± 0.5338.89 ± 0.498.32 ± 0.1444.73 ± 0.692.74 ± 0.23
LlamaNO SWITCH45.50 ± 0.167.48 ± 0.1142.18 ± 0.196.14 ± 0.1251.67 ± 0.102.07 ± 0.06
QwenSWITCH68.12 ± 0.634.29 ± 0.3165.41 ± 0.713.61 ± 0.4067.38 ± 0.481.15 ± 0.22
QwenNO SWITCH68.42 ± 0.632.58 ± 0.1169.51 ± 0.782.19 ± 0.1372.05 ± 0.420.68 ± 0.07

Table D. Domain-level: HotpotQA→2WikiMultihopQA→MuSiQue→StrategyQA. Switch before Stage 3 MuSiQue.

LLMAgent capabilitiesMasRouter AA ↑MasRouter AF ↓ARGDesigner AA ↑ARGDesigner AF ↓MASFACT AA ↑MASFACT AF ↓
LlamaSWITCH42.57 ± 0.525.48 ± 0.4143.91 ± 0.555.81 ± 0.5851.45 ± 0.622.02 ± 0.19
LlamaNO SWITCH45.26 ± 0.173.74 ± 0.1246.32 ± 0.184.27 ± 0.0952.31 ± 0.09−0.55 ± 0.04
QwenSWITCH64.33 ± 0.552.64 ± 0.1765.22 ± 0.631.92 ± 0.1669.13 ± 0.460.56 ± 0.07
QwenNO SWITCH67.28 ± 0.641.53 ± 0.0667.93 ± 0.711.68 ± 0.0970.38 ± 0.570.19 ± 0.06

Table E. Class-level: TACO, eight stages. Switch before Stage 5 Greedy algorithms.

LLMAgent capabilitiesMasRouter AA ↑MasRouter AF ↓ARGDesigner AA ↑ARGDesigner AF ↓MASFACT AA ↑MASFACT AF ↓
LlamaSWITCH60.21 ± 0.756.94 ± 0.3762.71 ± 0.737.09 ± 0.4264.31 ± 0.932.51 ± 0.23
LlamaNO SWITCH63.57 ± 0.284.90 ± 0.1165.67 ± 0.315.53 ± 0.1471.32 ± 0.09−0.11 ± 0.05
QwenSWITCH74.15 ± 0.833.29 ± 0.2375.78 ± 0.923.41 ± 0.3774.36 ± 0.541.28 ± 0.13
QwenNO SWITCH76.08 ± 0.621.98 ± 0.2778.73 ± 0.822.24 ± 0.3279.40 ± 0.530.49 ± 0.14

(Due to the character limit, our response to W2 continues in the next comment.)

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

The paper proposes a framework for continual learning of LLM multi-agent communication topologies. It mainly aligns historical topology priors with new task-specific agent spaces through Fused Gromov-Wasserstein optimal transport. Experiments across several scenarios demonstrate improvements in average accuracy and reductions in forgetting.

Critical strengths
  1. This paper is working on a practically important problem of continual adaptation of communication topologies in multi-agent systems.

  2. The proposed framework offers a systematic approach to reusing communication structures across heterogeneous agent spaces.

Critical weaknesses
  1. The presentation needs to be significantly improved. As important support for illustrating the challenges, the way the data in Figures 1(c) and 1(d) are retrieved is not clearly described. The overview in Fig. 2 fails to provide an informative illustration of the overall method and is obscure to read before a full understanding of the method definition. Geometry-aware posterior transfer is presented as a central mechanism, but the practical meaning of the transferred posterior is somewhat obscure.

  2. The formulation does not sufficiently distinguish how its topology forgetting failure mode differs from conventional parameter forgetting. The proposed method integrates existing techniques for constraining model updates for topology forgetting, but it fails to sufficiently reason about the design considerations, e.g., why existing continual-learning techniques are insufficient for such a setting.

Questions for authors
  1. The metrics of AA and AF, which are important for interpreting the results, need further explanation. The relative gains (Rel. Gains) of the results may not represent a meaningful performance comparison metric, e.g., how to interpret 189.04% lower for AF in Code in Table 2? What if a result of a baseline is already negative?
7 comments

Thank you! We would be glad to provide further details upon request.

W1-1: Data Source, Comparison Settings, and Findings for Figure 1(c)

Figure 1(c) reports accuracy on the current class after each stage of a class-incremental TACO sequence, averaged over five runs. We use GDesigner’s graph constructor and MAS configuration, initially training the constructor on 2,551 Data structures examples. Subsequent six stages include Dynamic programming and Complete search, with 10 support examples for few-shot adaptation and separate examples for evaluation.

The four curves compare current-support adaptation, semantic-only transfer, structure-only transfer, and MASFACT.

CurveActual implementation
Learn from few-shot supportUpdate the constructor using current-class support examples, without historical topology retrieval.
Historical Topology ReuseRetrieve by current-task semantics and directly reuse the most similar task’s historical topology.
Structure-Only TransferMatch and retrieve historical topology using scaffold structure alone, then directly execute the transferred graph.
MASFACTJointly align structure and semantics, then adapt through constrained residual updates.

This experiment yields the following findings:

  1. Few-shot constructor updates alone yield substantially lower accuracy on later classes. This illustrates the difficulty of adapting communication structures across classes with limited feedback. Comparisons on the same classes show the benefit of reusing historical collaboration alongside current-task feedback.

  2. Semantic-only and structure-only transfer fall below current-support adaptation at later stages. Comparisons on the same classes show that task-semantic similarity or graph-structural similarity alone does not ensure beneficial historical topology reuse.

  3. MASFACT achieves higher current-class accuracy, supporting the joint structural–semantic transfer emphasized in Challenge I. It matches both agent functions and communication relations, then adjusts connections using current feedback to adapt historical collaboration patterns to the current task.

W1-2: Learning Settings, Metric Computation, and Findings for Figure 1(d)

Figure 1(d) compares four learning settings for the same dynamic topology generator on a seven-class incremental TACO sequence, averaged over five runs. We use GDesigner’s graph constructor and MAS configuration, with both continual-learning variants sharing a base checkpoint trained on 2,551 Data structures examples. Subsequent classes include Dynamic programming and Complete search. Each of the seven classes contains over 500 training examples, averaging 1,505 per class.

The four settings compare few-shot and full-data continual updates with data-rich independent and joint training references.

SettingTraining procedure
Few-shot Continual LearningSequentially update one shared constructor using 10 support examples per new class.
Standard Continual LearningSequentially update one shared constructor using each new class’s full training set.
Independent LearningTrain and retain a separate constructor using each class’s full training set.
Joint LearningTrain one constructor jointly on all seven classes’ training data.

Lines report average accuracy (AA) after each stage, giving equal weight to all seen classes, while bars report average forgetting (AF) for the two continual-learning settings. AF averages earlier classes’ accuracy decreases relative to their best performance before the current stage. Metrics use held-out examples and are computed separately for each run before averaging. Independent- and joint-learning curves average their fixed trained models’ accuracies over the classes included up to each stage.

The experimental findings are as follows:

  1. Few-shot continual learning exhibits a substantial AA decline and increasing AF. Compared with the data-rich independent and joint references, these results show that continual updates with sparse feedback struggle to sustain overall performance and preserve effective collaboration on earlier classes.

  2. Standard continual learning exhibits faster AF growth at later stages. Earlier-class performance deteriorates despite using all current-class training data, showing that more current-task data alone does not preserve effective historical collaboration structures.

  3. These results expose a stability–plasticity challenge in adapting communication structures while agent capabilities remain fixed. The underlying LLM weights and agent configurations are fixed, while continual updates modify the graph constructor, supporting Challenge II: adapting to new tasks with sparse feedback while controlling structural interference and preserving effective collaboration on earlier tasks.

W1-3: Figure 2 Explained Through a Simplified Running Example

We apologize that the terminology and icons made Figure 2 difficult to follow. We trace an actual case from a task-level continual-learning run: a data-rich mathematics base stage trains the topology graph constructor and initializes the prior bank, followed by few-shot code adaptation and evaluation on a new HumanEval example. For each panel of Figure 2, we explain the reading order and then show the case’s topology. The retrieved atom belongs to the continually maintained shared prior bank.

(1) Left panel: Overall workflow.

  • Historical Topology Construction: After base-stage mathematics training, store effective collaboration relations with role attributes as historical atoms in the shared prior bank M\mathcal M. The blue cylinder represents the bank, and its graph icons represent collaboration patterns.
  • Geometry-Aware Prior Retrieval: Use the current task’s attributed graph (agent information and an initial communication proposal) to retrieve and align historical atoms, obtaining the green aligned prior center CtC_t.
  • Conservative Posterior Adaptation: Learn connection residuals from support feedback while constraining deviation from the aligned prior, then adjusting connection to produce the orange executable topology BtexecB_t^{exec}.
  • Selective memory update: The orange feedback arrow returns useful structural evidence to selectively refine existing atoms or expand the shared prior bank.

The four-node example uses the following functional correspondences.

FunctionHistorical nodeCurrent coding agent
PlanningP: PlannerP: Planner, decomposes implementation requirements.
Candidate generationS: SolverC: Coder, generates candidate code.
VerificationV: VerifierT: Tester, checks candidate code and forwards it with the test feedback.
AggregationA: AggregatorA: Aggregator, returns the final implementation.

The diagrams below show the retrieved historical atom and the current HumanEval scaffold.

Retrieved historical atom:             
[P] ──▶ [S] ──▶ [V] ──▶ [A]        
         │               ▲
         └───────────────┘
         
         
Current HumanEval scaffold:
[P] ──▶ [C] ──▶ [A]
 │               ▲
 └────▶ [T] ─────┘

(2) Middle panel: Match functions and relations jointly, then project historical collaboration onto the current agents.

  • Current attributed graph: The graph shows candidate connections, the color strip represents attributes such as roles and tools, and the dot row represents node weights for matching.
  • FGW soft coupling: FGW computes soft node correspondences by jointly minimizing mismatches in agent attributes and communication relations. Orange correspondence lines and the heatmap visualize the soft transport plan.
  • Prior retrieve from MM (prior bank): Select a historical atom by balancing alignment cost, historical utility, and structural dispersion.
  • Projection into the current task space: Use the selected atom’s soft correspondences to map its communication relations onto the current agents, forming the weighted prior center CtC_t.

In the example, the initial scaffold places coding and testing on parallel routes, so the tester does not receive the coder’s output:

[P] ──▶ [C] ──▶ [A]
 │               ▲
 └────▶ [T] ─────┘

Through the functional correspondences S↔C and V↔T, the historical S→V relation becomes C→T. The aligned weighted reference is:

[P] ──▶ [C] ──▶ [T] ──▶ [A]
         │               ▲
         └───────────────┘

(Due to the character limit, our response to W1-3 continues in the next comment.)

(This comment continues our previous response to W1-3.)

(3) Right panel: Residual editing, execution, and memory control.

  • Aligned prior center CtC_t: The green graph provides the reference, and the orange grid represents connection-score adjustments.
  • Residual editing: The green graph supplies CtC_t, and the orange grid represents learned connection-score adjustments. In this example, support feedback lowers the C→A score, removing the shortcut from the selected execution graph BtexecB_t^{exec}.
  • Adapted topology → Posterior qt(B)q_t(B) → Executable topology: Adjusted scores define probabilities over candidate graphs, illustrated by the small graph icons. An executable topology is then selected, shown in orange.

In this example, code-support execution feedback reduces the C→A connection score, yielding:

[P] ──▶ [C] ──▶ [T] ──▶ [A]

Candidate code passes through the tester, which forwards the code and its feedback to the aggregator for final output. New HumanEval examples use the learned connection adjustments through read-only inference.

  • Memory control: Support-set evidence passing the utility threshold refines compatible atoms (wrench) or creates new ones (plus). Held-out evaluation keeps both residual parameters and the bank unchanged. (Appendix D.6–D.7)
  • Theoretical support: The bound at the bottom combines empirical risk, posterior–prior complexity, alignment error, and prior dispersion to upper-bound expected current-task loss under sampled topologies, motivating conservative adaptation under the stated assumptions.

This is a simplified example for clarity, and we will add the complete case illustrated in Figure 2 to the revised paper.

W1-4: Practical Meaning of Geometry-Aware Posterior Transfer

  1. The posterior qtq_t is a learned distribution over communication graphs after current-task adaptation, used to determine communication during execution. A connection’s probability indicates how likely it is to appear in a sampled graph. Including that link allows one agent’s output to reach another directly. (Sec. 3.3, Eq. 8; Appendix D.1, Eq. 13)

  2. Geometry-aware posterior transfer turns effective collaboration relations from historical posteriors into a prior reference for the current task. When an execution graph passes the support-utility threshold, its posterior mean adjacency is mapped into the selected atom’s node coordinates for refinement, or stored as a new atom. Joint structural–semantic alignment then maps these accumulated relations onto current agents, providing the prior for current-task adaptation. (Appendix D.6, Eqs. 39, 41–44; Sec. 3.2, Eqs. 4, 7)

  3. The adapted posterior controls how intermediate outputs are transmitted and aggregated through the execution graph. Current support feedback updates connection scores while limiting departure from the historical reference. The selected graph determines which intermediate outputs reach other agents and can inform the final answer. (Sec. 3.3, Eq. 10; Appendix D.1, Eq. 16)

W2-1: Topology Forgetting and Its Relation to Parameter Forgetting

  1. Topology forgetting is performance degradation caused by failure to reconstruct effective communication structures for earlier tasks, whereas parameter forgetting concerns degradation caused by weight updates. We fix the underlying LLM weights and old-task agent configurations to examine how incorrect communication paths disrupt necessary information flow and reduce collective performance while individual task-solving capabilities remain unchanged. Parameter interference in the constructor can cause this structural failure, making effective communication among existing agents our explicit retention target.

  2. MASFACT freezes the constructor after base-stage training and adapts through task residuals and a shared historical bank. Baselines that continually update the constructor may alter old-task communication paths through new-task training. MASFACT instead retains task-specific connection residuals and reconstructs communication using the latest bank, explicitly targeting effective collaboration relations for retention.

  3. Table 15 directly tests the effect of collaboration structure by replacing only the communication graph. With agents, prompts, test questions, and execution budgets fixed, replacing the historical graph with the graph reconstructed after subsequent learning reduces MATH old-task accuracy from 63.10% to 53.74%. The MASFACT posterior graph restores accuracy to 62.58%, supporting communication structure as an explicit retention target. (Appendix G.4, Table 15)

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.