PaperlayerView exact revision on arXiv

Source-linked AI summary

Learning to Share: Selective Memory for Efficient Parallel Agentic Systems

Joseph Fioresi, Parth Parag Kulkarni, Ashmal Vayani, Song Wang, Mubarak Shah

arXiv:2602.05965v2cs.MAcs.AI

TL;DR

Parallel agent teams improve robustness but redundantly recompute overlapping steps, creating a runtime-efficiency problem. LTS adds a global shared memory and a learned controller trained with usage-aware reinforcement learning to selectively share useful intermediate results. On GAIA and AssistantBench, it reduces wall-clock runtime while matching or improving task performance over memory-free parallel baselines.

  • Problem

    Independent parallel teams repeatedly recompute overlapping intermediate steps, increasing runtime despite improved robustness.

  • Method

    LTS uses a global shared memory and a lightweight binary controller trained with stepwise reinforcement learning and usage-aware reward shaping to admit useful intermediate steps.

  • Results

    Across GAIA and AssistantBench, LTS improves task performance while drastically reducing wall-clock runtime compared with memory-free parallel baselines.

  • Takeaways & Limitations

    Learned memory admission is a promising strategy for improving the efficiency of parallel agentic frameworks without sacrificing solution quality.

  • Takeaways & Limitations

    Shared memory is instantiated per task, does not support long-term personalization, and does not reason about deletion or revision of stored entries.

Abstract

from arXiv · show

Agentic systems solve complex tasks by coordinating multiple agents that iteratively reason, invoke tools, and exchange intermediate results. To improve robustness and solution quality, recent approaches deploy multiple agent teams running in parallel to explore diverse reasoning trajectories. However, parallel execution comes at a significant computational cost: when different teams independently reason about similar sub-problems or execute analogous steps, they repeatedly perform substantial overlapping computation. To address these limitations, in this paper, we propose Learning to Share (LTS), a learned shared-memory mechanism for parallel agentic frameworks that enables selective cross-team information reuse while controlling context growth. LTS introduces a global memory bank accessible to all teams and a lightweight controller that decides whether intermediate agent steps should be added to memory or not. The controller is trained using stepwise reinforcement learning with usage-aware credit assignment, allowing it to identify information that is globally useful across parallel executions. Experiments on the AssistantBench and GAIA benchmarks show that LTS significantly reduces overall runtime while matching or improving task performance compared to memory-free parallel baselines, demonstrating that learned memory admission is an effective strategy for improving the efficiency of parallel agentic systems. Project page: https://joefioresi718.github.io/LTS_webpage/

1. Introduction

Parallel agent teams improve robustness by exploring diverse trajectories, but independent execution repeatedly recomputes overlapping steps and increases runtime. LTS addresses this with shared memory and learned admission, reducing redundancy while preserving task quality on GAIA and AssistantBench.

  • 1. Introduction: Independent parallel teams repeat web searches, table parsing, and code generation, while branch errors trigger retries that further increase runtime.Existing frameworks discard intermediate results after generation, even when other teams could reuse them.
  • 1. Introduction: LTS introduces a global shared memory that lets parallel teams selectively reuse intermediate results without forcing synchronization or unbounded context growth.Entries store concise textual summaries as retrieval keys and raw agent outputs as values.
  • 1. Introduction: The learned controller admits candidate steps through a binary decision and uses stepwise reinforcement learning with usage-aware reward shaping to identify globally useful information.This approach addresses sparse supervision from downstream task success while explicitly controlling memory growth.
  • 1. Introduction: Across GAIA and AssistantBench, LTS improves performance while drastically reducing wall-clock runtime relative to memory-free parallel baselines.The benchmarks contain long-horizon, tool-intensive tasks that expose redundancy in parallel execution.
  • 1. Introduction: The paper identifies computation redundancy, proposes global memory, and reports learned selective sharing as an efficiency improvement for parallel agentic frameworks.These contributions frame memory admission as a learned mechanism rather than indiscriminate sharing.

2. Related Works

Related work spans single-agent and multi-agent systems for tool-mediated reasoning, parallel trajectory generation for robustness, and memory mechanisms for persistent interaction. LTS differs by adding shared memory to parallel teams while focusing on within-task redundancy rather than long-term personalization.

  • Agentic LLM systems: Agentic systems iteratively plan, act, and use tools or environments, with structured pipelines supporting program synthesis, web interaction, and multi-tool coordination.These systems extend beyond single-shot generation to multi-step problem solving.
  • Parallel reasoning: Parallel reasoning methods generate multiple trajectories and aggregate their final outputs, improving robustness without sharing intermediate execution steps.M1-Parallel instantiates multiple independent MagenticOne-style teams and combines their candidate solutions with an LLM-based aggregator.
  • Memory in agentic systems: Agentic memory research primarily studies persistent structures for long-term interaction, personalization, and cumulative learning across episodes.This literature differs from LTS's task-local memory objective.
  • Baseline parallel agentic frameworks: MagenticOne uses a lead orchestrator and specialized agents sequentially, whereas M1-Parallel runs multiple such teams independently in parallel.In the paper's setting, the orchestrator consumes memory items when making later delegation decisions.

3. Method

LTS augments parallel agent teams with a global key-value memory bank and a lightweight controller that selectively admits useful intermediate steps. Its reinforcement-learning objective uses execution outcomes, group-relative advantages, and usage-aware shaping to promote reusable information while controlling context growth.

  • 3.1. Global Shared Memory Bank: LTS adds a global shared memory bank to parallel agent frameworks, storing intermediate steps as concise summary keys paired with raw agent outputs for cross-team reuse.Teams inspect summary keys and selectively retrieve corresponding values, avoiding forced synchronization or trajectory merging.
  • 3.2. Learned Memory Admission: The memory controller makes a binary admission decision for each candidate step, storing its summary-output pair only when the step is estimated to be globally useful.The controller is a lightweight language model operating alongside the agent teams.
  • 3.2. Learned Memory Admission: Controller decisions condition on the task query, existing memory summaries, and embeddings of the current input, output, and summary projected into the controller’s input space.Fixed-length embedded tokens preserve semantic context while keeping the controller lightweight and fast.
  • 3.3. Training the Memory Controller: Training uses episode rewards combining final aggregated-answer correctness with first-team correctness, then normalizes outcomes against independent executions for the same input.Group-relative advantages reduce sensitivity to heterogeneous task difficulty by favoring decisions that produce relatively better outcomes within each input group.
  • 3.3. Training the Memory Controller: Usage-aware shaping gives additional credit to admitted entries whose keys are actually selected during execution and contribute to a non-zero task reward.This provides denser supervision and reduces reinforcement of incidental admission decisions.

4. Experiments

Across GAIA and AssistantBench, LTS reduces runtime while improving task performance over memory-free parallel baselines. Analyses show that selective, learned memory admission enables efficient cross-team reuse without uncontrolled memory growth.

  • Runtime Reduction: LTS reduces mean AssistantBench completion time by 8.4 minutes and shifts the full runtime distribution left relative to M1-Parallel.The faster distribution persists despite the overhead of maintaining shared memory.
  • Task Performance: LTS improves task performance while substantially reducing runtime across GAIA and AssistantBench compared with memory-free parallel baselines.On GAIA, gains are +5.6 pp for Qwen3-32B and +1.2 pp for GPT-5.1; improvements are strongest on the hardest subsets.
  • Memory Admission Variants: Naively admitting every intermediate step reduces runtime but can lower accuracy, whereas LTS achieves the best accuracy with low runtime through selective admission.LTS-LLM improves over LTS-AddAll but adds computational overhead; learned selection balances efficiency and reliability.
  • Memory Utilization Analysis: LTS stores fewer memories while maintaining comparable recall and achieves the highest cross-team recall, indicating broadly useful intermediate results.By contrast, LTS-AddAll causes maximal memory growth while many stored entries are never reused.
  • Method ablation: Usage-aware shaping and sparsity are both necessary: removing them increases admissions and runtime without improving task accuracy.The full objective provides the best balance among task performance, runtime, and memory selectivity.
  • Scaling with parallel team count: Without retraining, LTS improves accuracy and runtime across tested parallel team counts, including a GAIA change from 25.4% to 31.6% and 2034s to 1234s at K = 5.The method continues to provide gains at K = 10 despite greater memory growth and redundant exploration.

5. Conclusion

LTS selectively reuses intermediate information across parallel agent teams through learned shared memory, reducing redundant computation while matching or improving task performance.

  • LTS reduces redundant computation while matching or improving task performance compared with memory-free parallel baselines.
  • The method combines a global memory bank with a lightweight controller that learns which intermediate steps are worth sharing.
  • Naive memory sharing does not achieve similar gains, indicating that learned memory admission is important for efficient parallel agentic execution.

Impact Statement

The paper aims to improve the efficiency and accuracy of agentic machine learning systems, without identifying immediate societal consequences unique to the contribution.

  • The primary goal is to advance the efficiency and accuracy of agentic machine learning systems.
  • The authors foresee no immediate negative societal consequences unique to this contribution beyond those associated with deploying large language model–based agents.
  • The approach may make advanced agentic workflows more accessible and environmentally efficient when computational cost limits performance.

Appendix Overview

The appendix provides dedicated sections for dataset details, implementation details, and additional results.

  • Section A covers dataset details.
  • Section B covers implementation details.
  • Section C covers additional results.

A. Dataset Details

The evaluation uses GAIA and AssistantBench, benchmarks designed around realistic, long-horizon tasks requiring multi-step reasoning and external-tool interaction.

  • GAIA evaluates reasoning, planning, and tool use on real-world tasks requiring multi-step execution and external information.
  • AssistantBench evaluates web-based agentic systems on practical long-horizon objectives involving planning, reasoning, and external tools.

B. Implementation Details

LTS uses a lightweight learned memory controller and trains it through multi-trajectory policy optimization on AssistantBench. Shared-memory variants reduce wall-clock latency relative to memory-free execution, while admission strategy affects accuracy and execution variability.

  • B. Implementation Details: A lightweight causal transformer based on Qwen3-0.6B implements the memory controller, with LoRA adapters and trainable projection layers while the remaining backbone stays frozen.The implementation uses PyTorch and runs on a single NVIDIA H100 GPU.
  • B. Implementation Details: The controller is trained exclusively on AssistantBench development tasks using five independent execution trajectories per epoch for five epochs, reusing trajectories ten times per epoch.Multi-trajectory sampling captures behavioral and reward variability for policy optimization under sparse supervision.
  • B. Implementation Details: All shared-memory variants shift AssistantBench completion-time distributions left relative to memory-free M1-Parallel, indicating lower wall-clock latency through cross-team reuse.The figure compares cumulative wall-clock completion-time distributions across shared-memory variants.
  • B. Implementation Details: Alternative admission strategies obtain larger runtime gains but lower task accuracy, showing that faster sharing can trade off against solution quality.The comparison concerns shared-memory variants on AssistantBench.

C. Additional Results

Additional results show that selective admission reduces runtime without the execution instability associated with indiscriminate sharing. Qualitative examples illustrate rejection of path-specific or erroneous steps and acceptance of broadly reusable information.

  • C. Additional Results: The learned controller filters intermediate steps that are locally useful but path-specific, because they offer little benefit to other parallel teams.Figure S3 illustrates rejection of an error-producing code step that yields no reusable intermediate result.
  • C. Additional Results: The controller admits intermediate steps that expose reusable information needed by multiple teams, such as validated content retrieved from a protein PDB file.Figure S4 uses the 5WB7 structure as an example of broadly useful information.
  • C. Additional Results: Naive admission lowers latency but can introduce noisy or misleading information that degrades task accuracy, whereas LTS achieves a more favorable runtime–accuracy balance.The runtime analysis contrasts alternative shared-memory admission strategies with the learned selective strategy.
  • C. Additional Results: All memory-enabled methods reduce wall-clock runtime relative to memory-free M1-Parallel, while naive LTS-All admission increases step-count variability through redundant or low-utility information.LLM-based filtering partially mitigates this variability, but the comparison favors selective learned admission for more consistent execution behavior.
Loading 2602.05965v2…