acceptodds
Under review as a conference paper at ICLR 2027

ASPECT: Agent-Specific Parameter-Efficient Core Tuning for Multi-Agent LLM Workflows

Abstract

Large language model multi-agent workflows increasingly use reinforcement learning to optimize specialized agents toward a shared system-level objective. This raises a fundamental question of what should be shared across agents and what should remain agent-specific. Existing parameter-sharing strategies either force multiple agents to update the same adaptation parameters or separate their adaptations entirely, creating a tension between parameter reuse and individual adaptation. To this end, we propose Agent-Specific Parameter-Efficient Core Tuning (ASPECT), which separates shared task-aligned adaptation structure from agent-specific parameter updates. ASPECT constructs a shared adaptation space from task calibration data and assigns each agent a compact private core within this space. This design allows agents to reuse common task structure while retaining distinct parameter adaptations and workflow-level coordination. Extensive experiments on Math and Code tasks demonstrate that ASPECT achieves a stronger performance–parameter efficiency trade-off than representative parameter-sharing baselines, with over 90% fewer trainable parameters.

Primary area:
reinforcement learning
Keywords:
Large Language Models, Multi-Agent Reinforcement Learning, Parameter-Efficient Fine-Tuning, Parameter Sharing

Reviews

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

ASPECT studies parameter-efficient reinforcement learning for multi-agent LLM workflows. It constructs frozen, task-aligned low-rank bases from calibration gradients and trains a private core matrix for each agent using GRPO. Experiments cover mathematical reasoning and code generation across three model scales and three workflows, reporting improved average peak validation accuracy with substantially fewer trainable parameters than standard LoRA sharing strategies.

Critical strengths
  1. The method addresses a practical trade-off between parameter sharing and agent-specific adaptation. Its compact private cores substantially reduce trainable parameter counts while allowing independent agent updates.

  2. The evaluation covers multiple model scales and workflow structures. The reported results provide encouraging evidence that this parameterization can be useful for multi-agent reinforcement learning.

Critical weaknesses
  1. The methodological contribution beyond existing work is limited. As acknowledged in Section 3.3, LoRA-XS already introduces core-only adaptation between frozen factors, and LoRA-SB provides task-aligned initialization through an estimated update and SVD. ASPECT mainly extends this construction by assigning separate cores to agents. The GRPO objective remains unchanged, and gradient isolation follows from using disjoint trainable parameters. Although the application is useful, I do not find the additional methodological insight sufficiently substantial for acceptance.

  2. The experiments do not sufficiently isolate the contribution of the proposed sharing design. The main baselines train complete LoRA factors, so comparisons change both the adapter parameterization and the sharing strategy. Comparisons using the same calibrated frozen bases with workflow-shared, role-shared, and agent-specific cores would more directly test the central design choice. The TSC ablation also changes both the bases and core initialization, limiting attribution. Consequently, the results establish a promising practical configuration more clearly than they establish the specific benefits of the proposed multi-agent design.

Questions for authors
  1. What technical contribution distinguishes ASPECT from applying LoRA-SB with separate agent cores beyond the extension to multi-agent workflows?

  2. Under the same calibrated bases and comparable tuning budgets, how do workflow-shared and role-shared cores compare with agent-specific cores? Can the effects of basis selection and core initialization be separated?

3 comments

Thank you for the thoughtful review. We address your questions on the design and ablations below.

Q1: What does ASPECT add beyond applying LoRA-SB separately to each agent?

A1: WS and RS save parameters by tying trainable updates; AS keeps updates independent but trains a full pair of LoRA factors per agent. Building on LoRA-SB calibration, ASPECT shares one frozen task-calibrated basis pair per layer and trains only a private r×rr\times r core per agent, without changing the GRPO objective (§§4.1–4.3). It uses over 90% fewer trainable parameters than the baselines (Table 2).

Qwen3-4B Orch-WorkersWSRSASASPECT
Trainable parameters132.12M396.36M660.60M5.16M

On AgentsNet maximal matching (Qwen3-4B, rank 64, one A100 80 GiB per run), both methods train at 16 agents, but ASPECT uses fewer resources (§5.9, Table 3).

Metric at 16 agentsASASPECT
Private trainable tensors7.88 GiB63 MiB
GPU Adam states15.75 GiB126 MiB
Resident training tensors39.10 GiB15.66 GiB
Mean weight sync163.23 s121.66 s

ASPECT cuts resident tensor memory by 59.9% and synchronization time by 25.5%.

We then increased the number of agents to 32. AS failed with a GPU out-of-memory error during weight synchronization, while ASPECT trained successfully.

32-agent testASASPECT
TrainingOOM during syncCompleted profiling run
Estimated GPU footprint at sampled peak-38.56 GiB

In the main experiments, ASPECT often approaches its later-stage training success level within about 100 updates, indicating faster convergence and higher sample efficiency (Appendix B.1, Figures 10–11). Across 18 settings, ASPECT reaches 96.34% of its step-200 mean validation accuracy by step 100, the highest ratio among the four methods.

MethodStep 100Step 200Step 100 / 200
WS28.07%32.40%86.65%
RS32.32%36.21%89.25%
AS30.88%36.98%83.51%
ASPECT36.57%37.96%96.34%

Across 18 settings, ASPECT has the highest mean validation accuracy under all three rules (Appendix B.1, Table 5).

Checkpoint ruleWSRSASASPECT
Peak32.94%37.98%37.48%39.80%
Step 20032.40%36.21%36.98%37.96%
Last five (160–200)31.75%36.07%36.01%37.78%

Q2: How do the three core-sharing schemes compare with the same calibrated bases and training budget?

A2: On Qwen3-1.7B Math Orch-Workers, we use the same frozen task bases, initial core values, and 200-update budget. Private cores retain competitive accuracy with lower late-stage training–rollout mismatch (§5.6, Figure 7).

Core assignmentPeak validationGlobal χ2\chi^2, steps 151–200
WS-core: one per workflow59.70%0.0461
RS-core: one per role62.54%0.0617
ASPECT: one per agent61.61%0.0421

Q3: Can basis choice and core initialization be separated?

A3: With task-calibrated bases fixed, calibrated core initialization raises peak validation accuracy from 59.49% to 62.46%. With R0=0R_0=0 fixed, task-calibrated bases reach 59.49%, compared with 44.19% for pretrained-weight bases (§5.7, Figure 8).

Frozen basisNonzero R0R_0Zero (R0=0R_0=0)
Task-calibrated62.46%59.49%
Pretrained-weight55.31%44.19%

The nonzero variants use a calibrated core for the task basis and a random core for the pretrained-weight basis. Both ablations support the same conclusion: task calibration and core initialization each contribute to ASPECT’s performance.

Thank you for the detailed response and additional experiments. The new scalability results and controlled ablations address some of my concerns and strengthen the empirical evidence. I have therefore raised my rating.

Thank you for revisiting the paper and raising your rating after considering the additional experiments. We appreciate your acknowledgment that the resource results and ablations strengthen the empirical evidence.

We would like to briefly clarify the design insight behind those results. Building on LoRA-XS and LoRA-SB, ASPECT addresses what to share across agents without tying their trainable updates. Each layer reuses one frozen task-calibrated basis pair, while each agent learns only its own compact core under the same GRPO objective (Sections 3.3 and 4). The experiments in Sections 5.6–5.7 support this choice by examining core sharing, basis selection, and initialization separately.

The practical value is supported by the single-A100 (80 GiB GPU memory) test in Section 5.9: ASPECT completes the 32-agent test where AS encounters OOM. The newly added B.7, Table 9 also shows that ASPECT has the highest mean validation accuracy at step 100 and reaches 96.34% of its step-200 mean using half the updates.

Together, these results connect the compact parameterization to effective early learning and practical memory savings. Thank you for prompting us to make this connection more explicit and test the design more directly.

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

ASPECT extends task-calibrated fixed-basis adaptation to multi-agent workflows, training private agent cores with GRPO. Across two tasks, three model sizes, and three workflows, it achieves a favorable accuracy–trainable-parameter trade-off against LoRA sharing strategies.

Critical strengths
  1. Separating shared task-aligned adaptation structure from private agent updates is a compelling design for multi-agent learning. It offers a meaningful way to reconcile parameter reuse with individual adaptation, moving beyond the choice between fully shared and fully separate adapters (Sections 3–4).
  2. The practical evidence is promising: over 90% fewer trainable parameters than the tested baselines, competitive accuracy across 18 configurations, and stable training diagnostics in the analyzed workflow (Tables 1–2; Figure 6).
Critical weaknesses
  1. The central design needs more direct validation. No experiment compares shared versus private cores within identical calibrated bases. The AS baseline already controls agent separation but uses full LoRA factors; the TSC ablation changes both bases and initialization. These comparisons do not isolate how much private cores contribute to accuracy and stability within the proposed shared space.
  2. Table 1 reports peak validation accuracy over 20 checkpoints, without independent final-test results or repeated-run uncertainty. Appendix D’s dispatch/batching differences between equivalent Eval-Opt partitions further complicate accuracy comparisons. The parameter savings are established more clearly than the precise performance ranking.
Questions for authors
  1. For one representative workflow, how do workflow-shared, role-shared, and private cores compare under identical bases, initialization, training budget, and dispatch?
  2. Do the principal accuracy gains persist on an independent test set after validation-based checkpoint selection, with uncertainty across repeated runs?
2 comments

We appreciate the reviewer’s positive assessment of the parameter savings and the helpful suggestions for a more direct comparison. We address the key questions below.

Q1: How do workflow-shared, role-shared, and private cores compare within the same subspace?

A1: On Qwen3-1.7B Math Orch-Workers, we fix bases, initial cores, rank 64, peak LR 2×10−42\times10^{-4}, and 200 updates. Private cores stay competitive and have the lowest late-stage mismatch (§5.6, Figure 7).

Core assignmentPeak validationGlobal χ2\chi^2, steps 151–200
WS-core: one per workflow59.70%0.0461
RS-core: one per role62.54%0.0617
ASPECT: one per agent61.61%0.0421

Q2: Can the effects of task calibration and core initialization be separated?

A2: With task-calibrated bases fixed, calibrated core initialization raises peak validation accuracy from 59.49% to 62.46%. With R0=0R_0=0 fixed, task-calibrated bases reach 59.49%, compared with 44.19% for pretrained-weight bases (§5.7, Figure 8).

Frozen basisNonzero R0R_0Zero (R0=0R_0=0)
Task-calibrated62.46%59.49%
Pretrained-weight55.31%44.19%

The nonzero variants use a calibrated core for the task basis and a random core for the pretrained-weight basis. Taken together, the results highlight the importance of both the task-calibrated bases and the core initialization.

Q3: Was the RS–AS dispatch discrepancy in Eval-Opt corrected?

A3: We matched AS's route-homogeneous batching and route checks, kept RS role-wise, and reran RS. See Table 1, Figures 10–11, Table 7 (Math), and Supplementary Material (“Aligned RS Eval-Opt”).

Eval-Opt settingOriginal RSAligned RS
Qwen3-1.7B Math50.07%53.82%
Qwen3-0.6B Code16.30%17.20%

Q4: Do the gains persist across seeds and fixed checkpoints, and was there a separate test?

A4: We evaluate checkpoints saved every 10 updates on the validation set, not a separate post-selection test. ASPECT leads on average across 18 settings, including at fixed checkpoints (Appendix B.1, Table 5).

Checkpoint ruleWSRSASASPECT
Peak32.94%37.98%37.48%39.80%
Step 20032.40%36.21%36.98%37.96%
Last five (160–200)31.75%36.07%36.01%37.78%

On Qwen3-1.7B Math Orch-Workers, ASPECT leads at every seed (Appendix B.6, Figure 16). Seed columns show peak accuracy in %; SD is sample SD.

MethodSeed 42Seed 43Seed 44Peak mean ± SD
WS41.0141.0146.2542.75 ± 3.03
RS51.6354.9653.1953.26 ± 1.67
AS49.7251.5651.4250.90 ± 1.02
ASPECT62.4659.9961.6161.36 ± 1.26

Thank you again for your constructive suggestion to test core sharing within the same adaptation space. We would like to briefly connect the new comparisons to the attribution and evaluation questions you raised.

Section 5.6, Figure 7 compares workflow-shared, role-shared, and private cores with common frozen bases, initial core values, and training budgets. Private cores retain competitive accuracy while maintaining more stable agreement between training and rollout policies. The zero-core ablations in Section 5.7, Figure 8 further distinguish the contributions of basis choice and core initialization.

We also aligned the affected RS Eval-Opt dispatch with AS, reran those configurations, and updated the results (Table 1; Supplementary Material, “Aligned RS Eval-Opt”). Fixed-checkpoint comparisons retain ASPECT's aggregate advantage (B.1, Table 5; B.7, Table 9), while the three-seed results now in B.6, Table 8 show consistent peak-accuracy gains in the tested workflow. These checks address checkpoint selection and variation between runs separately.

Before the discussion closes, we would appreciate hearing whether any aspect of the design comparison or evaluation remains unclear. We would be glad to provide further clarification.

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

The paper studies how trainable adaptation parameters should be shared among agents in reinforcement-learning-trained multi-agent LLM workflows. It argues that existing strategies either couple agents by making them update the same LoRA adapter (workflow-level or role-level sharing) or abandon shared structure entirely by giving every agent a full adapter (agent-level separation). It proposes ASPECT, which accumulates answer-token cross-entropy gradients on 50 calibration examples, applies a sign-normalized proxy update and a rank-64 truncated SVD to obtain frozen shared bases, and then lets each agent train only a private 64×64 core matrix inside that shared space during GRPO, with the backbone and bases frozen. It evaluates on DAPO-Math and DeepCoder with Qwen3-0.6B/1.7B/4B under Eval-Opt, Voting and Orch-Workers workflows against workflow-level sharing, role-level sharing and agent-level separation, reporting peak validation accuracy over 200 steps and trainable parameter counts. The main results show an average peak accuracy of 39.80% versus 37.73% (role-level) and 37.48% (agent-level) with 96–99% fewer trainable parameters, and training-rollout mismatch diagnostics comparable to full agent-level separation. The authors conclude that sharing frozen task-aligned structure while keeping updates private yields a better performance–parameter trade-off. The contribution is primarily methodological and empirical.

Critical strengths

Strength 1 : The parameterization resolves the sharing/separation tension in a way that is both cheap and stable: private r×r cores inside shared frozen task-aligned bases reproduce the low policy-mismatch and perplexity of full agent-level separation (Figure 6) at under 1% of its trainable parameters (Table 2). Evidence: Sec. 4.2–4.3, Table 2, Figure 6; parameter counts independently verified as internally consistent. Why it is consequential: This is the paper's most reliable result and the one practitioners will use: it says agent-specific adaptation in RL-trained MAS can be stored and synced as a few MB per agent instead of hundreds, without inheriting the gradient-conflict instability of shared adapters. The caveat, developed in Weakness 2, is that the saving is arithmetic at the tested scale (3-5 agents, four 140 GiB GPUs, where agent-level separation's ~8 GB of optimizer state fits comfortably); its practical bite appears only at fleet scale, which the paper does not test.

Strength 2: The diagnostic and analysis layer is above the norm for this subarea: training-rollout χ² and PPL per method and per role group (Figure 6), core-evolution heatmaps and singular-value spectra tying multi-agent updates to rank-1 dominance (Figure 7), an honest theory section that states its own limits (Appendix E), and a reproducibility package with code, prompts, configs and compute accounting. Evidence: Sec. 5.5–5.6, Figures 6–7, Appendix C–E, supplement README/THIRD_PARTY_NOTICES. Why it is consequential: Figure 6 and Figure 7 are citable independently of the method, and the transparency (including disclosing that identical parameter partitions yield different runs) lets a reader audit the weaker claims instead of having to trust them.

Critical weaknesses

Weakness 1: The headline accuracy claim is under-powered and partly an artifact of peak-checkpoint selection, and the cross-setting generality claim in Section 5.2 is contradicted by the paper's own table. Evidence: Table 1 (single seed 42, peak over 20 validation checkpoints, one workflow run per problem): ASPECT−RS +2.07 (paired t=1.65, p≈0.12), ASPECT−AS +2.31 (t=1.57, p≈0.14), sign tests p≈0.24/0.14; ASPECT loses to some baseline in 6/18 cells, by up to −9.85 (Math 4B Voting) and −9.63 (Math 0.6B Eval-Opt); per-subset margins are +5.71 (1.7B) and +5.39 (Orch-Workers) but −1.36 (0.6B), +0.18 (Eval-Opt), +0.64 (Voting). Appendix D's identical-partition RS-vs-AS probe shows sd 3.28 and a 6.87-point outlier; Appendix Figures 8–9 show ASPECT collapsing late in several cells that peak reporting hides. Why it is consequential: The abstract's "stronger performance–parameter efficiency trade-off" and Section 5.2's "advantages extend across both tasks and multiple model scales and workflows" are the paper's central claims; as reported they rest on a metric and a seed budget that the authors' own noise probe shows to be insufficient. What would resolve it: At least three seeds per configuration with paired confidence intervals; report final-step and mean-of-last-k validation accuracy next to peak; and either restrict the generality claim to the settings where it holds (1.7B, Orch-Workers, Code) or add cells demonstrating it elsewhere.

Weakness 2: The paper never demonstrates that its added machinery is necessary: the shared-subspace premise is not isolated against a private-subspace control, the parameter-efficiency benefit is not shown in any regime where plain per-agent LoRA is infeasible, and the closest conceptual antecedent for "shared foundation plus agent-specific low-rank refinement" (LoRASA, Zhang et al., arXiv:2502.05573) is neither cited nor discussed. Evidence: (i) The only ablation (Sec. 5.4, Figure 5) swaps calibrated shared bases for pretrained-weight shared bases; no per-agent private subspace variant (per-agent LoRA-SB/LoRA-XS at the same rank) exists, so shared-vs-private is untested. (ii) Every experiment runs 3-5 agents on four 140.4 GiB GPUs (Appendix D), exactly the regime where agent-level separation is affordable: at Qwen3-4B Orch-Workers, AS trains 660.60M parameters in total, i.e. ~1.6 GB of AdamW state per agent at ~12 bytes/parameter (~8 GB for five agents), which fits; ASPECT's corresponding figure is ~12 MB per agent. The 96-99% saving is therefore correct arithmetic but is never converted into a demonstrated capability gap - no configuration is shown where AS does not fit (memory, checkpoint storage, or rollout weight-sync bandwidth) and ASPECT does. (iii) Related Work (Sec. 2) lists Terry et al., Christianos et al., Kim & Sung, Qin et al., Tessera et al. for MARL parameter sharing but omits LoRASA, whose stated thesis ("combining a shared foundation for coordination with low-rank agent-specific refinements for individual specialization") is the thesis of this paper. Why it is consequential: Together these leave the two design choices under-motivated. Without the private-subspace control, "reuse common task structure" is an assumption rather than a finding; without a cost-bound regime, the paper's second headline ("over 90% fewer trainable parameters") answers a question the experiments never pose, and a reader in the tested regime has no evidence-based reason to prefer ASPECT over the simpler per-agent LoRA; without LoRASA, the novelty delta is overstated. What would resolve it: Three additions, each cheap: a per-agent private-subspace baseline at matched rank on the six configurations where ASPECT wins; one memory- or sync-bound configuration (or even an explicit optimizer-state and weight-sync-bandwidth accounting extrapolated to tens or hundreds of agent configurations) showing AS infeasible and ASPECT feasible; and a Related Work paragraph positioning against LoRASA and stating the delta (frozen shared task-aligned bases + r×r cores, LLM MAS under GRPO) explicitly.

Questions for authors

(Re: W1) [Clarification] Table 1 uses peak accuracy over 20 validation checkpoints from a single seed. Could you report, for the 18 configurations, the mean and spread over at least three seeds together with final-step accuracy, and state whether the ASPECT−RS and ASPECT−AS margins survive? Your Appendix D already shows that identical parameter partitions differ by up to 6.87 points, so a noise bound from repeated ASPECT runs at one configuration would also help. (Re: W1) [Potential correction] Appendix Figures 8–9 show ASPECT's validation accuracy declining late in several cells (e.g., Math 0.6B Eval-Opt, Code 0.6B Eval-Opt, Math 4B Eval-Opt/Voting), while Table 1 reports peaks. Which checkpoint is the peak in those cells, and does the paper's conclusion change if the metric is final-step or mean-of-last-5 accuracy? (Re: W2) [Clarification] Is there any configuration in which a per-agent private task-aligned subspace (per-agent LoRA-SB/LoRA-XS, same rank and parameter budget) was tried? If not, what in the current evidence separates "sharing the subspace helps" from "core-only training helps"? (Re: W2) [Clarification] How does ASPECT relate to LoRASA (Zhang et al., arXiv:2502.05573), which proposes a shared backbone with per-agent low-rank adaptation matrices for multi-agent policy learning? A short positioning paragraph would clarify the delta (frozen shared task-aligned bases + r×r cores, LLM MAS under GRPO). (Re: W2) [Clarification] All experiments run 3-5 agents on four 140.4 GiB GPUs, where agent-level separation's optimizer state (~1.6 GB per agent at Qwen3-4B, ~8 GB for five agents by my arithmetic from Table 2) fits comfortably. Can you show at least one configuration - or an explicit accounting of optimizer-state memory, checkpoint storage and rollout weight-sync bandwidth extrapolated to tens or hundreds of agent configurations - in which per-agent LoRA is infeasible and ASPECT is feasible? Without it, the parameter-efficiency claim remains arithmetic rather than demonstrated utility. (Re: W1) [Clarification] Baselines use a single learning rate (2e-5) in the main experiments while ASPECT uses 1e-4/2e-4; the three-rate sweep in Figure 10 covers only Qwen3-1.7B Math Eval-Opt. Can you confirm 2e-5 is also best for WS/RS/AS on the configurations where ASPECT's margin is largest (Qwen3-1.7B Orch-Workers, Qwen3-4B Code)?

2 comments

We thank the reviewer for the careful reading and constructive suggestions. Below, we address the main concerns in turn.

Q1: Do the accuracy gains persist without peak selection and across seeds?

A1: ASPECT has the highest mean validation accuracy under all three reporting rules across the 18 configurations (Appendix B.1, Table 5).

Checkpoint ruleWSRSASASPECT
Peak32.94%37.98%37.48%39.80%
Step 20032.40%36.21%36.98%37.96%
Last five (160–200)31.75%36.07%36.01%37.78%

On Qwen3-1.7B Math Orch-Workers, ASPECT leads at every seed (Appendix B.6, Figure 16). Seed columns show peak accuracy in %; SD is sample SD.

MethodSeed 42Seed 43Seed 44Peak mean ± SD
WS41.0141.0146.2542.75 ± 3.03
RS51.6354.9653.1953.26 ± 1.67
AS49.7251.5651.4250.90 ± 1.02
ASPECT62.4659.9961.6161.36 ± 1.26

Q2: When does ASPECT peak in the four highlighted settings, and how does it perform later?

A2: Some settings decline after the peak. The fixed-checkpoint results are below (Appendix B.1, Figures 10–11).

SettingPeak stepPeakStep 200Last five
Math 0.6B Eval-Opt9029.04%23.73%25.72%
Code 0.6B Eval-Opt13015.30%12.60%13.18%
Math 4B Eval-Opt16069.69%69.05%68.87%
Math 4B Voting20058.71%58.71%57.78%

Q3: Do the controls distinguish basis choice, subspace sharing, and core-only training?

A3: At the same rank and zero initialization, task-calibrated bases improve peak accuracy (§5.7, Figure 8).

Frozen basisNonzero R0R_0Zero (R0=0R_0=0)
Task-calibrated62.46%59.49%
Pretrained-weight55.31%44.19%

The nonzero variants use a calibrated core for the task basis and a random core for the pretrained-weight basis. These comparisons show that both task-aligned bases and core initialization contribute to higher validation accuracy.

With task bases and initialization fixed, private cores retain competitive accuracy with lower late-stage mismatch (§5.6, Figure 7).

Core assignmentPeak validationGlobal χ2\chi^2, steps 151–200
WS-core59.70%0.0461
RS-core62.54%0.0617
ASPECT61.61%0.0421

Together, the controls show that task-calibrated bases and private cores both contribute: calibration improves peak validation accuracy at fixed zero initialization, and private cores reduce late-stage mismatch while maintaining competitive accuracy in the same subspace.

Q4: How does ASPECT differ from LoRASA?

A4: LoRASA adds trainable low-rank factors to a shared MARL policy for cooperative control on SMAC and MAMuJoCo. ASPECT targets GRPO-trained multi-agent LLM workflows: agents share the frozen task-calibrated adaptation directions, not just the backbone, and train only private r×rr\times r cores (§§3.3, 4.1–4.3). We added LoRASA to Related Work (§2).

Q5: Do the parameter savings translate into practical memory or runtime benefits?

A5: On AgentsNet maximal matching (Qwen3-4B, rank 64, one A100 80 GiB per run), both methods train at 16 agents, but ASPECT uses fewer resources (§5.9, Table 3).

Metric at 16 agentsASASPECT
Private trainable tensors7.88 GiB63 MiB
GPU Adam states15.75 GiB126 MiB
Resident training tensors39.10 GiB15.66 GiB
Mean weight sync163.23 s121.66 s

ASPECT cuts resident tensor memory by 59.9% and synchronization time by 25.5%.

We then increased the number of agents to 32. AS failed with a GPU out-of-memory error during weight synchronization, while ASPECT trained successfully.

32-agent testASASPECT
TrainingOOM during syncCompleted run
Estimated GPU footprint at sampled peak-38.56 GiB

Q6: Could higher baseline learning rates explain the gap?

A6: At the same learning rate of 2×10−42\times10^{-4}, ASPECT still learns faster than WS and RS on Qwen3-1.7B Math Orch-Workers; AS's training success fluctuates more (Appendix B.5, Figure 15).

Learning rateWSRSASASPECT
2×10−42\times10^{-4}44.83%46.53%50.94%62.46%

Q7: Was the RS–AS dispatch discrepancy in Eval-Opt corrected?

A7: We aligned RS dispatch with AS while retaining role-wise LoRA, reran the affected RS settings, and updated Table 1, Figures 10–11, and Table 7 (Math). See Supplementary Material, README, “Aligned RS Eval-Opt.”

Eval-Opt settingOriginal RSAligned RS
Qwen3-1.7B Math50.07%53.82%
Qwen3-0.6B Code16.30%17.20%

Thank you again for your careful assessment of the robustness and practical value of our results. We would like to briefly highlight how the revised manuscript addresses your concern that the accuracy advantage might depend on favorable checkpoint selection or a particular seed.

Across all 18 configurations, ASPECT has the highest mean validation accuracy under all four summaries: peak, step 200, the last five checkpoints, and step 100 (Appendix B.1, Table 5; B.7, Table 9). The step-100 result shows that the advantage is already present halfway through training. The three-seed results are now included in B.6, Table 8: on Qwen3-1.7B Math Orch-Workers, ASPECT's peak accuracy exceeds all three baselines at every seed. The aggregate comparisons also incorporate the corrected RS Eval-Opt results following dispatch alignment with AS (Table 1; Supplementary Material, “Aligned RS Eval-Opt”).

To address your concern that parameter savings were only arithmetic, Section 5.9 and Table 3 report actual memory and synchronization measurements. At 32 agents on one A100 (80 GiB GPU memory), AS encounters OOM during synchronization, whereas ASPECT completes the test. This provides a concrete resource-constrained setting where the compact private cores make a practical difference.

As the discussion period approaches its end, could you please let us know whether any concerns remain unresolved? We would be happy to clarify them and appreciate the opportunity to discuss your assessment further.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.