acceptodds
Under review as a conference paper at ICLR 2027

Learning Who Knows What: Learned Role-Aware Agentic Memory in LLM-Based Multi-Agent Systems

Abstract

Persistent memory helps LLM agents reuse experience across tasks, but experience useful to one role may be unsuitable for another. We study how agents should decide whether to use memory and whose experience to consult for the current task. We propose LoRAM, a role-aware memory framework that separates source eligibility from online source selection. A role compatibility gate identifies eligible peers, while an online contextual policy selects among bypassing memory, using local experience, consulting a single peer, or combining local and peer memories under a common token budget. Memories remain in stores owned by individual agents, and only consolidated procedures are eligible for transfer between agents. A transactive directory tracks source expertise and directed transfer outcomes to inform routing decisions. We evaluate LoRAM on sequential Research, Database, and Coding tasks from MultiAgentBench. LoRAM achieves the highest observed mean scores among the evaluated configurations across all three environments. On Research with GPT-4o-mini, it also uses 15.7% fewer tokens per task than the strongest baseline by mean score. Research ablations compare the full method with local memory, shared access, static role routing, and provenance-aware item routing. These results suggest that learning whose experience to reuse is a promising approach to memory management in teams of specialized agents.

Primary area:
foundation or frontier models, including LLMs
Keywords:
LLM agents, multi-agent systems, agentic memory, lifelong agents

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

The paper proposes LoRAM (Learned Role-Aware Agentic Memory), which uses role-structured persistent memory to provide clear responsibility division. Each agent maintains its local episodes and consolidated procedures. And a global transactive directory is used to store provenance, compatibility information, and other metadata. The authors use a compatibility gate to filter peer sources and retrieve from separate candidate sets. A contextual LinUCB policy selects among bypass, local, single-peer, and local-plus-peer access under the same memory budget. For evaluation, they use 100-task streams from three MultiAgentBench environments (Research, Database, and Coding), where LoRAM achieves the highest mean scores and reduces token usage compared with other memory frameworks.

Critical strengths
  1. The concrete design and formulation are logically motivated. In particular, LoRAM proposes and clearly separates several useful components: role compatibility, task expertise, transfer history, and search relevance. It also combines compatibility gating with UCB routing over different actions, which is reasonable since the router needs to balance using sources that have worked well before with exploring sources whose utility is still uncertain. These constitute a meaningful architectural contribution to persistent shared memory.
Critical weaknesses
  1. The experimental results are not sufficiently convincing. The authors evaluate LoRAM on three different environments, while the main improvements are relatively small, especially on the Research and Coding tasks. These marginal improvements are also not shown to be stable through confidence intervals or variance estimates. In addition, since this is a sequential and evolving process, task order may also matter. Evaluating alternative task orders could therefore help assess the stability of the reported improvements.
  2. Some experimental designs make it difficult to attribute the gains to learned source routing. For example, full LoRAM and LoRAM-Local do not have access to equally sized retrieval spaces. LoRAM-Local searches only the target agent’s own memory, whereas full LoRAM additionally retrieves top-K candidates from each eligible peer, resulting in a larger candidate set. The adapted item-routing baseline is also not a fully controlled comparison. It uses a fixed heuristic scoring function, while LoRAM learns a scorer and additionally chooses among bypass/local/cross-agent/hybrid access. The LoRAM-StaticRole comparison could help isolate the value of online learning, but its exact fixed routing rule is not specified.
Questions for authors
  1. Could the authors specify the "fixed routing policy" used by LoRAM-StaticRole? Specifically, how does it select the access mode and peer source?

  2. Could the authors provide a more controlled ablation on the number of retrieved candidates across LoRAM-Local and full LoRAM? For example, the two variants could have access to the same amount of memory, while one pool contains only local memories and the other includes memories from eligible peers. This would help separate the benefit of more diverse cross-agent memory from simply having access to a larger retrieval corpus.

  3. Could the authors report results under different task orders or provide uncertainty estimates such as confidence intervals? Given the small improvements across the three environments, a performance stability check would be very important.

3 comments
AuthorsOpenReview ↗

Response to Reviewer S6bc

We sincerely thank the reviewer for recognizing the motivation and architectural contributions of our work. We address the concerns regarding experimental robustness, routing-policy design, and retrieval fairness through additional experiments and clarifications below.

W1 / Q3 — Task-Order Robustness and Limits of Stability Evidence

We evaluated Full LoRAM and the baselines on three matched permutations of the same 100 Research tasks with GPT-4o-mini. Memory, directory, and routing state were reset between orders, allowing each method to learn independently on the same task sequence.

Table B1. Matched Research order checks (GPT-4o-mini; 100 tasks/order).

OrderFullStaticRoleLLMA-MemFull − StaticRoleFull − LLMA-Mem
order_00 (original)87.6287.3487.38+0.28+0.24
order_0187.5487.1187.22+0.43+0.32
order_0287.2486.9187.00+0.33+0.24
Mean87.4787.1287.20+0.347+0.267

As shown in Table B1, Full LoRAM consistently outperforms both StaticRole and LLMA-Mem across all three matched task orders, achieving average improvements of +0.347 J and +0.267 J, respectively. The positive margins across different task permutations demonstrate that LoRAM's performance improvements are reproducible across the evaluated task sequences, providing additional empirical support for the effectiveness of adaptive source routing.

W2 / Q1 — Exact StaticRole Routing Rule and What It Controls For

The fixed routing rule used in our comparison is described as follows. StaticRole retains the same profile-initialized compatibility gate (θ_role=0.55), source-preserving local/peer top-K retrieval (K=5), transfer eligibility restriction to consolidated peer procedures, and common memory-token budget (B=1,000). It does not select actions using learned LinUCB weights. Instead, it applies a deterministic access rule:

  1. Local and eligible peer candidates available: choose Hybrid(i,j*), where j* is the eligible peer with the largest fixed prior role-profile similarity (ties broken by fixed role index).
  2. Only an eligible peer has candidates: choose Cross(j*) by the same role-priority rule.
  3. Only local candidates available: choose Local.
  4. Neither source has candidates: choose Bypass.

Memory cards are still packed under the same B=1,000 budget. This comparator tests whether a task-conditioned online router is useful beyond a simple deterministic role-priority heuristic. It should not be interpreted as a gate ablation or as the same control as Frozen: Frozen keeps the LinUCB action-scoring equation active while holding its learned parameters fixed, whereas StaticRole replaces that scoring process with a deterministic action rule.

W2 / Q2 — Candidate-Pool Size and Fairness of Full Versus Local-Only Retrieval

To examine retrieval space size directly, we audited 1,000 logged decisions across order_01 and order_02. Each decision contained on average 4.20 local candidates and 8.80 eligible peer-procedure candidates; 24% of local decisions had fewer than five local records. This motivates a comparison with a common maximum number of pre-budget candidates.

For the order_00 control, each variant receives a single global cap of C≤5 candidates across its combined sources, followed by the same memory-token budget B=1,000. The cap is global, rather than five candidates per source.

Table B2. Global candidate-cap comparison (Research; GPT-4o-mini; order_00).

Variant (C≤5)Research JTokens/task
Full source routing87.42147.6k
Learned item routing87.26151.9k
Fixed item routing87.16157.8k
StaticRole87.13151.6k
Local-only87.03142.3k

Under the shared cap, Full achieves +0.39 J over Local-only and +0.16 J over LearnedItem. This experiment controls the maximum candidate count and the final prompt-memory budget. Actual nonempty candidate counts still reflect store contents—for example, early local memories can contain fewer than five records—so we interpret this as a global candidate-cap-controlled comparison, with retrieval diversity remaining part of the system design.

Thank you for the detailed rebuttal.

The response has addressed several of my concerns. But I still have some reserverations: (1) Although the gains are consistent across the three task orders, they remain very small. (2) The robustness analysis is still limited to the Research environment.

I prefer to maintain my rating.

Thank you for your follow-up and for recognizing that our rebuttal has addressed several of your concerns. We appreciate your careful consideration of the additional experimental results.

Regarding the remaining concerns, we would like to highlight that LoRAM demonstrates improvements across all three environments, with larger gains in Database and Coding. As reported in Table 2, LoRAM improves Database accuracy from 35.00 to 40.00 (+5.00 percentage points) and Coding performance from 69.01 to 71.51 (+2.50 points) over LLMA-Mem. These results complement the Research findings and provide evidence of LoRAM's effectiveness across different task settings.

During the rebuttal, we specifically prioritized Research for additional robustness evaluations and controlled ablations, as its smaller performance margin made it a particularly important setting for examining the robustness and contributions of adaptive source routing. The new experiments show consistent positive improvements across three matched task orders, together with additional evidence from component-level comparisons.

Given the limited rebuttal period, we concentrated our experimental efforts on these targeted Research evaluations rather than repeating the full multi-order study across all three environments. We believe the combination of the original cross-environment results and the newly added Research experiments provides meaningful and complementary evidence supporting LoRAM's effectiveness.

Thank you again for your constructive feedback and consideration.

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

The paper studies who owns experience in a multi-agent system and which agent should provide experience for the current task. LoRAM gives each agent local memory, filters peers with a role-compatibility gate, and uses a LinUCB-style policy to choose among bypass, local, cross-agent, and hybrid access. It evaluates MultiAgentBench’s Research, Database, and Coding environments, with 100 sequential tasks per environment. LoRAM obtains the highest observed mean in all three environments, but the main results come from one task stream per environment and the margins are small.

Critical strengths
  1. “Who knows what” is a useful entry point. The paper separates storage ownership, role compatibility, source selection, and item retrieval, while preserving provenance during cross-agent transfer.
  2. The system is engineered in a fairly complete way. Three task environments, two backbones, a shared memory-token budget, local/shared/static/item-routing comparisons, and explicit failure handling provide an executable system design.
Critical weaknesses
  1. The solution is too composite, and its central necessity is not clear. Role gates, source expertise, transfer history, and LinUCB are introduced together, while the ablations also change the source set and selection policy. The paper does not show that source-level routing itself is better than simpler item routing or a fixed rule.
  2. The evidence does not establish a practical gain, and the release materials are not actually available. Each environment has only one fixed-order 100-task stream, and the Research gain over the strongest baseline is only 0.2–0.3 points. Even if the problem is well motivated, these results do not show that the complex router is worth the added machinery. The paper promises code and logs as anonymous supplementary material but provides no anonymous source link.
Questions for authors
  1. Can you use multiple random seeds and task orders in each environment, report task-level paired intervals, and test whether the 0.24-point and 0.20-point Research gains are stable?
  2. With candidate sets, retrieval depth, token budget, and task streams fixed, can you separately disable the role gate, LinUCB update, hybrid action, and provenance feature to isolate their contributions?
  3. Can you record and audit concrete negative-transfer events, or provide counterfactual/replay analysis showing that the router avoids harmful peer selection? Please also fix and report the judge model version, add a non-source-matched evaluation if possible, and provide links to anonymous source code, configurations, and run logs.
5 comments
AuthorsOpenReview ↗

Response to Reviewer oTRM (1/3)

We thank the reviewer for recognizing the value of the “who knows what” formulation and the completeness of our system design. We provide additional controlled comparisons and clarify the limits of the evidence below.

W1 - Necessity of Learned Source Routing Versus Fixed and Item-Level Alternatives

To clarify the necessity of each component, we distinguish three complementary functions rather than treating LoRAM as a single composite retrieval mechanism:

  1. Role compatibility (vs. StaticRole): Determines which peer sources are eligible for memory transfer. StaticRole retains role-based eligibility but replaces adaptive source selection with a fixed role-priority rule, allowing us to assess the benefit of dynamic routing beyond static role-based decisions.
  2. Source-aware retrieval and contextual evidence (vs. LearnedItem): Retrieves local memories and eligible peers' consolidated procedures separately, preserving source ownership and provenance. Source expertise and directed transfer history then inform source-level decisions. LearnedItem instead performs online contextual scoring over individual memory items under the same compatibility gate and B=1,000 token budget, allowing us to compare learned source-level routing with learned item-level routing.
  3. Online policy learning LinUCB (vs. Frozen LinUCB): LinUCB selects among bypass, local, cross(j), and hybrid(i,j) based on contextual features and observed outcomes. Frozen LinUCB retains the same action space, contextual features, and evolving memory and directory statistics but disables updates to the LinUCB parameters (A,b), isolating the incremental contribution of online policy learning.

These comparisons address distinct aspects of the design: StaticRole tests adaptive selection against a fixed rule, LearnedItem compares routing granularity while controlling for online learning, and Frozen LinUCB evaluates the contribution of policy updates. Together, they provide a more targeted assessment of why LoRAM combines role-aware eligibility, source-level routing, and outcome-driven adaptation.

Table O1. Matched Research comparisons (GPT-4o-mini; 100 tasks per order; joint score J).

Task orderFullStaticRoleFrozen LinUCBLearnedItemLLMA-Mem
order_00 (original)87.6287.3487.4387.2087.38
order_0187.5487.1187.3087.3187.22
order_0287.2486.9187.0787.0687.00
Mean87.4787.1287.2787.1987.20

Across the three matched orders, Full − LearnedItem is +0.42, +0.23, and +0.18 J (mean +0.277 J), while Full − Frozen averages +0.20 J and Full − StaticRole averages +0.347 J. The first comparison more directly probes source-level versus learned item-level decisions; the second probes the incremental contribution of LinUCB updates; and the third compares against a simple deterministic source rule. In a complementary order_00 comparison imposing a global pre-budget candidate cap C≤5, Full achieves 87.42, versus 87.26 for LearnedItem, 87.16 for fixed item routing, and 87.13 for StaticRole. The capped LearnedItem score (87.26) is distinct from its uncapped original-order result (87.20). This common cap reduces the candidate-space confound, but it does not guarantee identical realized nonempty candidates or isolate the routing unit as a single causal factor. We therefore interpret the results as consistent evidence for the evaluated learned source-routing design, not as a claim that source routing necessarily dominates all possible item routers.

AuthorsOpenReview ↗

## Response to Reviewer oTRM (2/3)

W2 / Q1 — Task-Order Robustness, Practical Gains, and Reproducibility

We evaluated two additional Research permutations alongside the submitted original order. Each method processes the same 100 tasks in each order, with memory, directory, and policy state reset between permutations. Full outperforms LLMA-Mem on the three orders by +0.24, +0.32, and +0.24 J (mean +0.27 J). The corresponding gains are +0.28, +0.43, and +0.33 J against StaticRole and +0.19, +0.24, and +0.17 J against Frozen LinUCB.

For transparency, the task-level paired 95% confidence intervals for Full minus LLMA-Mem are [−0.31, 0.98], [−0.39, 1.03], and [−0.43, 1.01] across order_00–02. Against Frozen LinUCB, the corresponding intervals are [−0.17, 0.55], [−0.16, 0.64], and [−0.17, 0.51]. These intervals span zero, while the observed mean differences are positive in all three matched orders. As an additional benchmark reference, the original Coding comparison has a reported +2.51-point paired difference with 95% CI [+0.68, +4.38] on the Coding task metric.

Regarding practical efficiency, the submitted order_00 comparison reports 147,511 tokens/task for Full versus 175,018 for LLMA-Mem, a 15.7% reduction at a modest +0.24 J difference. This token comparison applies to the original order, not a three-order average; it also does not measure end-to-end wall-clock or router overhead. We accordingly frame the benefit as a favorable observed score–token tradeoff on that stream, rather than a universal efficiency guarantee.

Reproducibility. We have provided an anonymous repository: https://anonymous.4open.science/r/LoRAM-anonymous-release-CD75/ . We will reference it in the revised manuscript and make the correspondence between released implementation, experiment configurations, and available run logs explicit.

Q2 — Component Ablations for the Gate, Policy Updates, Hybrid Access, and Provenance

To assess the contribution of each routing component separately, we performed the four requested single-component interventions on the same order_00 Research stream, retaining retrieval depth K=5, memory-token budget B=1,000, and the evaluation protocol wherever applicable.

Table O2. Component ablations (Research, GPT-4o-mini, order_00).

ConfigurationJΔ vs FullWhat changes
Full LoRAM87.62—Original configuration
Compatibility gate disabled (θ=0.0)87.23−0.39Allows peer sources regardless of compatibility
LinUCB (A,b) updates frozen87.43−0.19Keeps the evolving directory and memory, but freezes policy-weight updates
Hybrid action disabled87.41−0.21Removes local-plus-peer access as one action
Router provenance feature masked87.38−0.24Removes provenance from router features, not from memory-card labels

Each intervention lowers J on this stream (0.19–0.39 J), suggesting that these design choices are useful in the tested setting. The interventions should not be interpreted as additive causal contributions. In particular, gate removal necessarily changes peer eligibility and thus the realized action/candidate sets; masking provenance only in the router avoids simultaneously changing what the LLM sees in the selected memory cards. These details are essential to interpreting the controls.

AuthorsOpenReview ↗

Response to Reviewer oTRM (2/3)

Q3 — Negative-Transfer Replay Audit and Judge-Model Provenance

To evaluate the risk of harmful transfer from peer-memory access through cross/hybrid routing, we conducted a matched pre-task-snapshot replay audit of 16 selected agent–task decisions; 14 had valid checkpoints (two were excluded for missing snapshots). For each valid decision we compared a forced local-only option against peer transfer from the same pre-task state. With |ΔJ|>0.5 as the effect threshold, the replay contains 6 beneficial, 5 harmful, and 3 near-tied peer-transfer cases. LoRAM selected peer access in 5 of 6 beneficial cases and local access in 4 of 5 harmful cases.

ExampleForced Local JForced Peer JPeer − LocalLoRAM choice
cf_02 (beneficial peer transfer)84.8087.60+2.80Peer
cf_07 (harmful peer transfer)89.0086.60−2.40Local

The audit also includes one missed beneficial transfer and one harmful peer choice. This is a small, selected diagnostic sample; it does not provide a population estimate of negative-transfer prevention or prove causal credit for individual agents. We will describe the replay-selection protocol and exclusion criteria explicitly.

For judge provenance, Appendix E reports Azure OpenAI gpt-4o-mini, API version 2024-12-01-preview, judge temperature 0.0, and the scoring rubrics. The API version identifies the service interface, not an immutable model snapshot; we do not invent a snapshot identifier absent from the recorded metadata.

Reviewer_s83qOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper studies persistent memory in role-structured LLM multi-agent teams and argues that existing designs fix the availability scope of experience through storage organization, namely local, shared, or hybrid tiers. It proposes LoRAM, which treats memory reuse as an explicit online decision for each agent-task pair: a role-compatibility gate determines eligible peers, and a LinUCB-style contextual policy chooses among bypassing memory, using local memory, consulting one compatible peer, or a budgeted hybrid of local and peer memory under one shared token budget. Only consolidated procedures are eligible for cross-agent transfer, and a transactive directory tracks source expertise and directed transfer outcomes. On three MultiAgentBench environments with two backbones, LoRAM reports the highest observed mean scores among the compared configurations, and on Research with GPT-4o-mini it uses 15.7% fewer tokens per task than the strongest baseline by mean score.

Critical strengths
  1. Motivation: The problem is well motivated and crisply positioned. The decomposition of multi-agent memory design into storage ownership, availability scope, item retrieval, and source selection in Section 1 is a genuinely useful conceptual contribution, and the distinction between item-level routing as in RCR-Router and source-level routing as in LoRAM is clearly argued in Section 2 and Appendix D. Role-incompatible transfer as a first-class failure mode, that is negative transfer relative to the local or bypass counterfactual, is a real and understudied concern in memory-augmented teams, grounding the work in the transactive memory notion of who knows what.

  2. Method design: The framework is technically coherent and thoughtfully engineered. The four signals of relevance, source expertise, directed transfer history, and role compatibility are kept explicitly separate in Section 4.2, with compatibility acting as a hard gate and the rest entering the router as features, which avoids a common conflation. Restricting cross-agent transfer to consolidated procedures while keeping raw episodes local-only is a sensible guard against exposing unconsolidated traces. The source-preserving candidate construction, provenance-labeled memory cards, and the single shared token budget across access modes make comparisons between actions clean. The authors are also commendably careful in stating that directory statistics are outcome associations rather than isolated causal effects.

  3. Experiments: The evaluation spans three environments of quite different character, namely open-ended research generation, interactive database diagnosis, and executable coding, plus two backbones, with paired task ordering across configurations to support comparison. The routing-design ablations in Table 3 cover the right alternatives: local-only, unstructured shared, static role routing, and adapted item routing under the same gate and budget. The paper is unusually honest about its own evidence: it states that final CMA restates the mean-score difference, that routing-action frequencies in Appendix F do not isolate policy learning, and that single task streams do not support stability claims across seeds.

Critical weaknesses
  1. The central claim that online adaptation matters is not convincingly supported by the ablations. LoRAM-StaticRole, which removes outcome-driven adaptation entirely, reaches 87.34 in Table 3, only 0.28 below full LoRAM on the same single stream, and adapted item routing reaches 87.28. Given weakness 1, the performance ordering among the full method, static routing, and item routing is within noise, so RQ3 is effectively unanswered. The shift toward cross and hybrid actions over the stream in Table 5 is suggestive, but as the authors themselves note, candidate availability and task composition drift can produce this shift without any policy learning.

  2. The credit assignment underlying the bandit update is weak. The reward in Eq. 5 is a normalized team-level joint score that mixes task quality with planning and communication rubrics, and the same reward updates the policy parameters of every agent in the team, although each agent took a different memory action. Memory decisions are therefore partly rewarded or punished for changes in communication quality that are unrelated to memory content, and per-agent credit is acknowledged to be approximate, but no remedy such as leave-one-out rewards, per-agent outcome features, or a counterfactual baseline is explored. Relatedly, the reward is non-stationary because memory accumulates and consolidation rewrites stores every 2 tasks, yet the LinUCB formulation assumes a fixed reward mapping, and no sensitivity analysis for the exploration coefficient of 0.25 is given.

  3. The role-compatibility gate has an underspecified supervision source. Section 4.1 states that compatibility is updated only when an explicit role-pair transfer label is available, yet the paper never defines where such labels come from, how often they occur, or whether obtaining them requires extra LLM calls. In the reported runs it is unclear whether the gate ever moved beyond its embedding-similarity prior with strength c of 4, and there is no sensitivity analysis for the gate threshold of 0.55, even though this threshold determines the entire eligible action space for cross and hybrid decisions.

Questions for authors

Please refer to the weaknesses.

3 comments
AuthorsOpenReview ↗

Response to Reviewer s83q (1/2)

We sincerely thank the reviewer for the thoughtful assessment and for recognizing the value of our formulation and role-aware design. We address the concerns regarding online adaptation, credit assignment, and role compatibility with additional experiments and clarifications below.

W1 - Online adaptation beyond static routing and task-order effects

We thank the reviewer for raising this important concern about single-stream ablations and the action-frequency trends. To handle those concerns, we introduce two additional ablations: Frozen LinUCB and LearnedItem and repeat the comparisons across three matched task orders.

1. Isolating the contribution of online policy learning.

Our most direct new ablation is Frozen LinUCB, designed to distinguish online contextual policy learning from other mechanisms that evolve throughout the task stream. Frozen LinUCB retains the same role-compatibility gate, source-preserving retrieval, consolidation schedule (N=2), routing action space, and action features as Full LoRAM. Crucially, it also retains live updates to source expertise and directed transfer statistics in the transactive directory. Its only intended difference is that the LinUCB policy parameters are not updated from observed task rewards.

We also added another ablation LearnedItem which extends the original fixed-score item-routing baseline with outcome-driven item-level learning. This allows us to compare online learning at the item level with LoRAM's online selection of memory sources and access modes.

For the new experiments, we evaluate Full LoRAM and the additional ablations on three matched permutations of the same 100 Research tasks using GPT-4o-mini as below.

Table S1. Research comparisons (GPT-4o-mini).

Task orderFullStaticRoleFrozen LinUCBLearnedItemLLMA-Mem
order_00 (original)87.6287.3487.4387.2087.38
order_0187.5487.1187.3087.3187.22
order_0287.2486.9187.0787.0687.00
Mean87.4787.1287.2787.1987.20

Online policy learning. The most relevant result is the Full–Frozen LinUCB comparison. Full LoRAM achieves higher scores in all three matched orders, with differences of +0.19, +0.24, and +0.17 J, averaging +0.20 J. Because Frozen LinUCB retains evolving memory stores, source statistics, and the same contextual action representation, this consistent positive margin provides evidence that updating the LinUCB policy contributes additional performance beyond these mechanisms.

Routing design. We also observe consistent improvements over StaticRole (+0.28, +0.43, and +0.33 J; mean +0.35 J). This larger margin is consistent with the combined benefit of contextual policy selection and online updates relative to fixed role-based routing, although the comparison does not isolate the contribution of each component.

Finally, for the results of LearnedItem, full LoRAM outperforms LearnedItem on all three orders (+0.42, +0.23, and +0.18 J; mean +0.28 J). This suggests that learning to select memory sources and access modes can be beneficial relative to the evaluated learned item-selection approach.

In summary, the new comparisons show that our proposed LoRAM is consistently better across the isolated ablation schemes on evaluated task permutations.

Table 5 Clarification: We would like to clarify the interpretation of Table 5: As memories accumulate, more consolidated peer procedures become available, changing the feasible action set. Differences in task composition may also affect the distribution of selected actions. We therefore interpret Table 5 as a descriptive characterization of routing behavior, rather than evidence that LinUCB updates caused the shift toward peer access. The new ablation above addresses a related but more direct question: whether updating the contextual routing policy improves overall task performance beyond a policy operating with evolving memory and source information but without reward-driven parameter updates.

AuthorsOpenReview ↗

Response to Reviewer s83q (2/2)

W2 / Q2 - Team-level credit assignment, non-stationarity, and exploration sensitivity

We thank the reviewer for raising these concerns regarding credit assignment, non-stationary rewards, and exploration sensitivity. We clarify our design rationale and provide additional empirical comparisons below.

Team-level reward and credit assignment: LoRAM is designed to optimize collaborative task performance in a role-specialized multi-agent system. For each task, agents make individual memory-routing decisions but jointly produce a task outcome through planning, communication, and execution. We therefore use the normalized team-level joint score, (J=(TS+CS)/2), as feedback for the selected routing action of each participating agent.

This provides a shared optimization objective across agents and captures both task quality and coordination, which may be affected by the relevance and compatibility of retrieved memory. For example, access to an appropriate peer procedure may improve an agent's contribution to team planning or help avoid redundant communication. Consequently, coordination quality is relevant to the intended objective, even though it is not a direct measure of memory quality.

To evaluate this design choice, we compare the default joint reward with two alternatives on the original Research task stream:

order_00 reward configurationResearch JTokens/task
Default joint team reward87.62147.5k
Task-quality-only reward (TS)87.52148.8k
Leave-one-agent-out reward rollouts87.55185.0k

The default achieves the highest observed J on this stream. Task-quality-only feedback reaches 87.52 J (148.8k tokens/task), while leave-one-agent-out rollouts reach 87.55 J (185.0k tokens/task) and consume approximately 25% more tokens than the default. These results highlight the observed performance–cost tradeoff and support our choice of team-level feedback as a computationally efficient learning signal.

Non-stationarity clarification: We acknowledge that LoRAM operates in a non-stationary environment, as memory accumulation and periodic consolidation (N=2) alter the available candidates and may change the expected rewards of routing actions over time. We therefore use LinUCB as a practical online contextual routing mechanism that adapts to evolving memory states, without assuming a stationary reward mapping or claiming classical LinUCB regret guarantees. Its effectiveness is evaluated empirically rather than through theoretical regret bounds.

To evaluate sensitivity to the exploration coefficient, we conducted two additional runs with α=0.10 and α=0.50. The results show that the end-to-end runs with α=0.10 / 0.25 / 0.50 obtain J=87.49 / 87.62 / 87.42, respectively; the default α=0.25 gives the highest observed score among these settings.

W3 / Q3 - Compatibility Supervision, Posterior Updates, and Threshold Sensitivity

We thank the reviewer for raising this important question. We clarify that compatibility updates are based on observed cross-role transfer outcomes during normal task execution and require no additional LLM calls. The gate is therefore not purely static: across the reported runs, we recorded 46 posterior updates involving 5 distinct role pairs, which shifted their compatibility estimates away from the embedding-based priors.

We additionally conducted a threshold sensitivity analysis with θ ∈ {0.40, 0.55, 0.70}, yielding J = 87.51, 87.62, and 87.43, respectively. The variation across these settings is limited, indicating that the method is relatively insensitive to moderate changes in the compatibility threshold. The default θ = 0.55 achieves the highest observed score among the evaluated settings.

We will clarify the supervision procedure and report the posterior-update statistics and sensitivity results in the revised manuscript.

AuthorsOpenReview ↗

Follow-up on Rebuttal and Remaining Concerns

Thank you again for your thoughtful review. We have provided additional experiments and clarifications addressing your concerns regarding online adaptation, credit assignment, and role compatibility.

As the author–reviewer discussion deadline is approaching, we would greatly appreciate it if you could take another look at our rebuttal and let us know whether the rebuttal address your main concerns or if any questions remain.

Thank you for your time and consideration.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.