acceptodds
Under review as a conference paper at ICLR 2027

AgentFugue: Agent Scaling for Long-Horizon Tasks through Collective Reasoning

Abstract

Recent progress on long-horizon agentic tasks has been driven largely by scaling up individual agents through stronger models, better tools, and more effective scaffolding. In contrast, much less is understood about scaling out: whether multiple peer agents, all targeting the same task, can become an additional source of capability without relying on explicit role specialization or workflow orchestration. We study this question and propose AgentFugue, a collective reasoning framework built around a shared reasoning hub. As peer agents explore the same task in parallel, the hub records concise notes on what each agent has established, attempted, or ruled out, and enables each agent to selectively access what other agents have discovered in a form useful for its current search. This design turns otherwise isolated trajectories into a connected ecology of reusable intermediate reasoning without requiring centralized planning. We instantiate the hub as a plug-in communication layer, trained with supervised fine-tuning and end-to-end reinforcement learning. Across the challenging long-horizon settings we study, AgentFugue improves over strong baselines. Our results suggest that collective reasoning can turn scaling out peer agent systems into a distinct source of capability gains, rather than merely a way of spending more compute.

Primary area:
foundation or frontier models, including LLMs
Keywords:
Multi-Agent, Scaling Law, Long-Horizon

Reviews

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

This paper proposes AgentFugue, a multi-agent framework designed to improve long-horizon reasoning through intermediate information sharing among peer agents working on the same task. Unlike conventional multi-agent systems that rely on explicit role specialization or centralized task decomposition, AgentFugue allows multiple agents to explore independently while exchanging their intermediate findings through a shared reasoning hub.

The hub supports two main operations: (1) episode writing, which compresses completed interaction histories into concise notes while preserving the original trajectories for subsequent access; and (2) intent-driven reading, which retrieves and synthesizes relevant episodes from other agents according to the requesting agent's current information needs. The hub is initialized from Qwen3.5-9B and optimized using supervised fine-tuning followed by GRPO, while the task agents remain frozen.

The authors evaluate AgentFugue on BrowseComp, WideSearch, and Humanity's Last Exam (HLE), using both homogeneous and heterogeneous agent teams. The reported results show improvements over the selected single-agent and multi-agent baselines. Additional experiments investigate how performance changes with team size, answer aggregation strategies, and context budgets.

Critical strengths

(1) The paper addresses an important challenge in long-horizon multi-agent reasoning: how multiple agents working on the same task can benefit from one another's intermediate findings without relying on predefined roles or centralized task decomposition. The proposed shared reasoning hub provides a practical mechanism for asynchronous information exchange through episode summarization and intent-conditioned retrieval. Its separation from the underlying agent policies also makes the framework potentially applicable to different agent backbones.

(2) AgentFugue reports encouraging improvements over the selected multi-agent baselines across BrowseComp, WideSearch, and HLE, including substantial gains on BrowseComp. The experiments additionally examine homogeneous and heterogeneous agent teams, scaling with team size, and different answer aggregation strategies. The success and failure cases in Appendix E are particularly useful because they illustrate both the potential benefits of sharing intermediate exploration results and the risk of propagating misleading evidence across agents.

Critical weaknesses

(1) The central components of AgentFugue—trajectory summarization, shared memory, selective retrieval, and outcome-driven optimization—have been extensively explored in previous studies. In particular, AgentFold and Context Folding investigate long-horizon context compression; ParallelMuse studies parallel exploration and intermediate trajectory reuse; AggAgent investigates selective access to multiple reasoning trajectories; and MemSifter explores task-oriented memory retrieval through a separately optimized model.

While AgentFugue combines these components into an online peer-agent communication framework, the paper does not sufficiently establish which methodological contribution goes beyond their integration. The use of a shared hub for intermediate information exchange is practically meaningful, but the claimed distinction between collective reasoning and existing trajectory reuse or memory-augmented agent mechanisms remains underdeveloped. Moreover, the proposed target knowledge space is primarily conceptual and does not lead to measurable or theoretically grounded properties.

(2) The interaction budgets are not clearly comparable across systems. Appendix A states that Naive- and Swarm-Multi-Agent allocate up to 100 rounds to each subagent and 50 rounds to the meta-agent, whereas each AgentFugue peer can use up to 150 rounds. This difference introduces a potential confounding factor, particularly because the paper attributes the improvements primarily to the shared reasoning hub.

(3) Several essential ablations are missing. In particular, the paper does not provide sufficiently controlled comparisons with single-agent memory using the same hub, independent peer agents with identical context management but without cross-agent communication, or untrained/SFT-only hub variants. Consequently, the individual contributions of shared communication and hub optimization remain unclear.

(4) The claim that collective reasoning provides capability gains beyond simply increasing computation is not adequately supported. Although Figure 2 shows decreasing search and visit calls per agent as team size increases, this does not imply a reduction in total per-task computation. The additional agents and hub calls must also be considered. Comparisons under matched total token budgets, tool calls, or inference costs are necessary to substantiate this claim.

(5) The evaluation lacks sufficient uncertainty estimates and statistical analysis. BrowseComp and HLE are evaluated on 200-question samples, with only 100 questions used in the scaling study. The paper does not clearly report independent-run variance or confidence intervals. Moreover, Appendix H shows that changing the hub budget from 64K to 32K increases BrowseComp BoN@2 accuracy from 50.0% to 58.0%, suggesting substantial sensitivity to an important configuration parameter whose effects are not sufficiently disentangled.

Questions for authors

(1) Could the authors clarify how AgentFugue differs technically from ParallelMuse, AggAgent, and MemSifter, beyond integrating their related ideas into an online multi-agent setting? In particular, which component or mechanism is responsible for a capability that cannot be obtained through a straightforward combination of existing methods?

(2) Appendix A states that each subagent in Naive-/Swarm-Multi-Agent is limited to 100 rounds, whereas each AgentFugue peer receives 150 rounds. How are the total computational budgets made comparable, including meta-agent and hub inference costs? Do the reported improvements persist when the systems are matched in total model tokens, tool calls, and interaction budgets?

(3) Could the authors provide controlled ablations comparing (a) AgentFugue without cross-agent reading but with identical context compression, (b) a single agent using the same hub, (c) an untrained hub, and (d) an SFT-only hub? These comparisons would help distinguish the contributions of shared reasoning, memory management, and reinforcement learning.

(4) Does each sampled policy output correspond to an individual write/read operation or an entire multi-agent rollout? How are task-level rewards assigned to multiple hub interactions, and are the write and read models optimized separately or jointly? Please clarify the reward formulation, group size, rollout construction, and training budget.

(5) Appendix H reports a substantial performance difference between 32K and 64K configurations. Can the authors explain whether this effect arises from episode granularity, communication frequency, or context length? Additionally, can they provide confidence intervals or multiple-run statistics for the main comparisons and clarify the evaluation protocol underlying the reported accuracy values?

11 comments
AuthorsOpenReview ↗

[ Part 1/4 ] Rebuttal for Reviewer sR7y

Thank you for reading our work carefully. We first explain the motivation for the study and its design, then respond to your comments.

First, this paper studies whether scaling out by adding parallel agents can improve reasoning. As with test-time scaling, this approach uses more inference compute in pursuit of better results. Parallel agents naturally use more resources than a single agent. The direct comparison is with the same number of agents exploring independently and aggregating answers at the end. If sharing during exploration cuts redundant searches and helps agents find better paths, it may improve accuracy under the same team budget or achieve the same accuracy at lower cost. Our efficiency experiments examine this trade-off.

Second, AgentFugue's design was inspired by the practice of internal “team races” in companies. Several teams work on the same difficult problem in parallel, with each team choosing its own direction. If teams compare outcomes only at the end, early discoveries and ruled-out directions arrive too late to help others. AgentFugue preserves each agent's ability to choose its next action while allowing it to use its peers' evidence, ruled-out directions, and unverified leads. We ask whether this exchange changes what agents search for next and improves their chances of solving the task. We therefore measure final team accuracy and individual accuracy before aggregation.

With these two points in mind, we address your comments in the five sections below.

W1 / Q1: Online Sharing

Thank you for comparing AgentFugue with these related works. You asked how AgentFugue differs from prior work on context compression, trajectory reuse, and memory retrieval. We focus on how discoveries from one peer's search can guide another peer that is still exploring the same task.

1. The methods differ in when exploration results enter another reasoning process.

WorkHow information is reused
AgentFoldCompresses an agent's own trajectory for later steps.
Context FoldingReturns a completed subtask's summary to the parent context.
ParallelMuseReuses prefixes when branching and combines compressed trajectories after exploration.
AggAgentSearches completed trajectories to synthesize the final answer.
MemSifterUses a trained model to select and rank memories for the current task.

Each AgentFugue peer works on the full task and chooses its own next action. A peer can use another peer's discoveries before its own search ends. This communication can change which candidate answers are produced even when the final aggregator stays the same. We therefore examine both final team accuracy and individual accuracy before aggregation.

2. An unfinished search can still help another agent.

Even before finding a correct answer, a peer can rule out candidates, verify constraints, or leave a lead worth following. Appendix E.1 shows this in a task about the founding year of a Shanghai shop. Two peers ultimately answer 1885 and 1848, but their intermediate findings help Agent-0 solve the task.

  1. Step 34. Agent-0 reads a peer's record of rejected candidates and a lead about imported cloth in eastern Shanghai.
  2. Steps 35–37. Agent-0 checks the peer's leading candidate first. When that line of inquiry stalls, it investigates the lead about cloth and finds a source giving 1853 as the founding year.
  3. Steps 38–43. Agent-0 cross-checks the evidence and gives the correct answer.

The trace shows how a peer's intermediate work guides a new search even when that peer eventually answers incorrectly.

3. The mechanism leads to observable changes in the search.

To let a peer act on another peer's work during exploration, the system must make episodes available promptly, help peers locate relevant episodes, and return evidence suited to their current search. In AgentFugue, peers write episode notes asynchronously. A receiving peer uses the notes to find relevant episodes and asks the hub to synthesize the raw content for its current search intent. The result can guide the peer's next action.

The target knowledge space describes the evidence and reasoning needed to solve a task. Different trajectories may uncover different parts of that space. We assess sharing through final team accuracy, individual accuracy before aggregation, and how agents use shared information in their search traces.

AuthorsOpenReview ↗

[ Part 2/4 ] Rebuttal for Reviewer sR7y

W2 / W4 / Q2: Compute

You pointed out the round limits in Appendix A and asked whether the advantage holds under matched compute when the coordinator and hub are included. The round limits align the maximum interaction depth of a single task path. We measure team usage across all roles, including the coordinator and hub. We report the limits and how often systems reach them, then compare systems under a common budget.

  1. Path depth and how often systems reach the limit. In Naive and Swarm, the coordinating agent assigns tasks and combines the results, and subagents carry out the work. A path through one subagent can use up to 150 rounds, with 50 for the coordinating agent and 100 for the subagent. AgentFugue has a 150-round limit per peer, since each peer searches and answers on its own. Giving both levels 150 rounds would allow up to 300 rounds along a path through the coordinator and a subagent.

    BenchmarkNaiveSwarmAgentFugue
    WideSearch (200 questions)2/200 (1.0%)3/200 (1.5%)1/200 (0.5%)
    HLE (200 questions)3/200 (1.5%)4/200 (2.0%)2/200 (1.0%)

    The rate is at most 2% on both benchmarks. We therefore expect the round limits to have little effect on the results for these two benchmarks.

  2. Actual team resource use. In the BrowseComp scaling experiment in Figure 2(b), increasing the team size from one to two reduces mean search and visit calls per agent from 40.49 to 37.14. The two-agent team makes a total of about 74.28 search and visit calls per question, plus 1.09 memory calls. The per-agent retrieval count in Figure 2(b) measures the work of an individual agent. For total team usage, we sum input and output tokens from the task agents, coordinator, hub reads and writes, and final aggregation for each question. We count tool calls and actual interaction rounds separately.

  3. Sharing during exploration improves accuracy under a common budget. We compare independent parallel exploration with AgentFugue on the same BrowseComp questions. Both use two Qwen3.5-35B-A3B task agents, the same local context compression, and the same final aggregator. The independent peers can access only their own notes and raw episodes. Both groups explore in parallel and select an answer at the end, so the comparison tests access to peer findings during exploration. Naive and Swarm use the same team budget. The per-question limits are 1.25M total team tokens and 80 search and visit calls.

    MethodAccuracyMean team tokens per questionMean search and visit calls per question
    Naive44.0%1.12M65
    Swarm45.0%1.18M77
    Independent peers with local compression and the same aggregator45.5%1.23M76
    AgentFugue48.0%1.22M74

    AgentFugue and the independent peers have similar mean token usage. AgentFugue makes 2 fewer search or visit calls per question and scores 2.5 percentage points higher. The task model, team size, local compression, and aggregator are the same. Agents can use their peers' checks and ruled-out leads and spend their remaining searches on unresolved parts of the problem.

AuthorsOpenReview ↗

[ Part 3/4 ] Rebuttal for Reviewer sR7y

W3 / Q3: Ablations

Thank you for suggesting controlled ablations to distinguish the contributions of the system's components. Your four proposed controls address two questions about how much cross-agent communication contributes and how much hub training contributes. We examine communication ablations, training stages, and a comparison that holds local memory management fixed.

1. Communication mechanism. The content and manner of sharing both affect performance.

On BrowseComp, we hold the task agents, tools, context budget, and answer aggregation rule fixed.

ConfigurationChangeAccuracy
No writeDisable writes of exploration episodes to the shared hub.38.5%
No readRetain episode writes and shared notes, and disable intent-conditioned reads of raw episodes.41.0%
Raw broadcastExpose peers' raw trajectories directly, with no selective reading or intent-conditioned synthesis.39.0%
Prompt-only hubUse the untuned Qwen3.5-9B with prompts for writing and reading.45.5%
SFT hubUse Qwen3.5-9B after supervised fine-tuning.48.0%
SFT+GRPO hubFull AgentFugue.50.0%
  • Shared notes and intent-conditioned reads serve different purposes. No read still lets peers see compact notes and follow the team's progress. Its accuracy is 41.0%, 9.0 percentage points below the full method. Access to raw evidence for the agent's current question improves performance beyond this overview.
  • Selective access is more effective than direct broadcast in this setting. Raw broadcast reaches 39.0%, 11.0 percentage points below the full method. Organizing shared information into notes and reading relevant details on demand yields higher accuracy than exposing raw trajectories directly.

No write disables writes of shared episodes and reaches 38.5%. The isolation experiment below retains local compression and each peer's own memory, and blocks only cross-agent access. It tests the contribution of cross-agent communication while preserving local memory management.

2. Hub optimization. SFT and GRPO each improve accuracy under a fixed communication interface.

The prompt-only, SFT, and SFT+GRPO variants share the same 9B backbone and communication interface. Their accuracies are 45.5%, 48.0%, and 50.0%, respectively.

  • Prompt-only to SFT: +2.5 percentage points. Supervising episode writing and intent-conditioned reading improves task performance under the same interface.
  • SFT to SFT+GRPO: +2.0 percentage points. Downstream task feedback provides an additional benefit after supervised training.
  • Prompt-only to full training: +4.5 percentage points. This comparison measures the gain from hub training under a fixed communication interface.

A 27B hub trained with LoRA reaches 48.5%, below the full 9B hub at 50.0%. This gives an additional comparison between two hub configurations with different backbones and training methods. Our estimate of the training gain comes from the three variants of the same 9B backbone above.

3. Local memory. Cross-agent communication improves accuracy when local memory management is held fixed.

To address your request for single-agent memory and independent-peer controls, we compare three configurations on the same BrowseComp questions. All three use the same trained hub, local write threshold, compression method, and read interface. The two-agent configurations also use the same team budget limits and final aggregator.

ConfigurationLocal memory managementCross-agent accessAccuracy
Single agent with the same hubRetainedNo peers40.0%
Two independent peers with the same hubRetained separately for each peerBlocked for both notes and raw episodes45.0%
Two peers with full AgentFugueRetainedShared notes and intent-conditioned reads enabled50.0%
  • Adding an independent peer raises accuracy from 40.0% to 45.0%. This measures the gain from an additional independent search path and answer aggregation.
  • Enabling cross-agent communication in the two-agent setup raises accuracy from 45.0% to 50.0%. Local compression, the hub checkpoint, and final aggregation are the same. The 5.0-percentage-point gain measures the benefit of giving agents access to peer findings during exploration within this setup.
Reviewer_XmWiOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

Authors focus whether peer agents can solve long-horizon tasks more effectively with a sharing intermediate progress memory. To do that, introduce a shared reasoning hub that stores compact episode notes and provides intent-conditioned access to teammates’ discoveries, called AgentFugue. The hub is trained through SFT and RL while the task agents remain frozen. According to author claim, their experiments lead improvements over the evaluated multi-agent baselines on BrowseComp, WideSearch, and HLE environments.

Critical strengths
  • Authors focus on a timely and important problem by analyzing how parallel agents can improve one another’s search rather than simply combine final answers.

  • Their proposed method outperforms the evaluated multi-agent baselines across both backbones and all three benchmarks. Examining individual-agent accuracy alongside team performance is also valuable, as it probes whether collaboration improves the agents’ own trajectories rather than merely selecting a better final answer.
Critical weaknesses
  • The main issue of the manuscript comes from experimental comparisons which do not clearly shows that the gains come from better coordination rather than differences in computational budget; where the interaction rounds favor AgentFugue. Moreover, fewer tool calls per agent do not establish lower total cost. A comparison under matched total inference budgets is important for supporting the paper’s central claim.


  • Another concern is the benefit of training the hub is not shown separately from the benefit of the communication design itself. For instance, hub is trained with SFT on GPT-5.4 rollouts and then with GRPO, but the ablation is on the context budget. It would be helpful to compare a prompt-only hub, an SFT-only hub, and the full SFT+GRPO hub under the same interface, so we can understand whether the training (and especially the RL stage) is what leads the actually gains. 



  • Finally, some conclusions are feels stronger than what the reported results support. Authors claim that AgentFugue gives the strongest results on every benchmark claim is only true within the same-backbone multi-agent block, where (for example) Table 1 itself shows the cited Kimi-K2.5 baseline above both AgentFugue configurations on HLE. Furthermore, the heterogeneous-team gains are read as complementary reasoning, yet the same numbers are fully consistent with weaker agents simply copying the strongest peer's answer through the hub.

Questions for authors
  1. What are total tool calls and tokens per question for every system in Table 1, and can the baselines be rerun with matched totals
  2. Does Table 1 use the SFT+GRPO hub? What do SFT-only, untrained Qwen3.5-9B, and GPT-5.4-as-hub give?
  3. Why deploy 64K when 32K is better under every aggregator, and on which questions was 32K selected?
  4. Could the authors provide a plot of accuracy against total token cost, with AgentFugue and all baselines on the same axes, so that the gains can be assessed under matched compute?
7 comments
AuthorsOpenReview ↗

[ Part 1/4 ] Rebuttal for Reviewer XmWi

Thank you for recognizing AgentFugue's performance in same-backbone multi-agent comparisons and our analysis of individual search behavior. Your comments helped us distinguish more clearly between the motivation for the paper and the claims we need to test. We would like to explain two points first, as this may make things a little clearer for you.

First, this paper studies whether scaling out by adding parallel agents can improve reasoning. This has the same motivation as test-time scaling: using additional inference compute to improve task performance. Parallel exploration naturally uses more resources than running one agent. The direct comparison is with the same number of agents exploring independently and aggregating their answers at the end. If sharing during exploration cuts redundant searches, the team may achieve higher accuracy under the same budget or reach the same accuracy at lower cost. This is the efficiency question we test.

Second, our idea was inspired by the practice of internal “team races” in companies. Explaining this may make our idea easier to understand intuitively. Several teams work on the same difficult problem in parallel, with each team choosing its own approach. If they compare results only at the end, a team that rules out a direction early cannot help others who are still pursuing it. AgentFugue lets each agent choose its next step and draw on peers' evidence, ruled-out directions, and open leads as needed. We ask whether communication before exploration ends changes what agents search for next. We therefore measure both final team accuracy and individual accuracy before aggregation.

W1 / Q1: Compute

You pointed out that the round limits may favor AgentFugue and that fewer tool calls per agent are insufficient to establish a lower team cost. The round limits were chosen to align the maximum interaction depth of a single task path.

  1. Round limits and how often systems reach them. In Naive and Swarm, the coordinating agent assigns tasks and combines the results, and subagents carry out the work. A path through one subagent can use up to 50 rounds for the coordinating agent and 100 for the subagent, for a total of 150. Each AgentFugue peer handles the full task from search to final answer, so each peer trajectory has a 150-round limit. Giving both levels 150 rounds would allow up to 300 rounds along a path through a coordinating agent and a subagent. This is the basis for allocating rounds by task path. The table below reports how often each system reached its limit.

    BenchmarkNaiveSwarmAgentFugue
    WideSearch (200 questions)2/200 (1.0%)3/200 (1.5%)1/200 (0.5%)
    HLE (200 questions)3/200 (1.5%)4/200 (2.0%)2/200 (1.0%)

    All systems reach their limits on at most 2% of questions on these two benchmarks. Direct truncation is rare, and the baselines seldom have to answer early because they run out of rounds. We therefore expect the round limits to have little effect on the results for these two benchmarks.

  2. Total team usage in the original runs. For each question, we sum input and output tokens across all roles, including task agents, the coordinator, hub writes and reads, and final aggregation. We also count tool calls. Each cell gives mean total tokens and mean tool calls per question.

    SystemBrowseCompWideSearchHLE
    Qwen ReAct0.63M / 400.91M / 560.36M / 13
    GLM ReAct0.82M / 460.99M / 600.42M / 15
    DeepSeek ReAct0.78M / 441.02M / 620.44M / 16
    Qwen Naive1.53M / 811.88M / 1050.81M / 30
    Qwen Swarm1.59M / 852.01M / 1140.88M / 34
    Qwen AgentFugue1.61M / 761.96M / 1010.86M / 28
    DeepSeek Naive1.60M / 831.97M / 1090.90M / 33
    DeepSeek Swarm1.67M / 872.10M / 1170.97M / 36
    DeepSeek AgentFugue1.71M / 802.02M / 1050.94M / 31

    With Qwen on BrowseComp, AgentFugue uses 1.61M tokens per question versus 1.59M for Swarm, an increase of about 1.3%. Accuracy rises from 45.2% to 50.0%. On WideSearch, AgentFugue uses 1.96M tokens versus 2.01M for Swarm and raises accuracy from 70.4% to 72.3%. These totals include the hub and coordination costs.

    Figure 2(b) measures a different quantity. When the team grows from one agent to two, mean search and visit calls per agent drop from 40.49 to 37.14. The two-agent team makes about 74.28 search and visit calls per question in total, plus 1.09 memory reads. Each agent performs less retrieval work, while total team retrieval increases.

AuthorsOpenReview ↗

[ Part 2/4 ] Rebuttal for Reviewer XmWi

  1. Sharing during exploration improves accuracy under a common budget. We compare independent parallel exploration with AgentFugue on the same BrowseComp questions. Both use two Qwen3.5-35B-A3B task agents, the same local context compression, and the same final aggregator. The independent peers can access only their own notes and raw episodes. Both groups explore in parallel and select an answer at the end, so the comparison tests access to peer findings during exploration. Naive and Swarm use the same team budget. The per-question limits are 1.25M total team tokens and 80 search and visit calls.
MethodAccuracyMean team tokens per questionMean search and visit calls per question
Naive44.0%1.12M65
Swarm45.0%1.18M77
Independent peers with local compression and the same aggregator45.5%1.23M76
AgentFugue48.0%1.22M74

AgentFugue and the independent peers have similar mean token usage. AgentFugue makes 2 fewer search or visit calls per question and scores 2.5 percentage points higher. The task model, team size, local compression, and aggregator are the same. With access to peers' checks and ruled-out leads, agents can use their remaining searches on unresolved parts of the problem.

W2 / Q2: Hub Training

You pointed out that the threshold ablation leaves the contributions of communication design and hub training unresolved. We vary the training stage under a fixed communication interface, then vary what information the system shares under a fixed training setup. Both task backbones in Table 1 use the same Qwen3.5-9B SFT+GRPO hub checkpoint. We apologize for the confusion about which checkpoint was used.

  1. SFT and GRPO each improve accuracy under the same interface. We change the hub configuration while holding the task agents, tools, context budget, and final aggregator fixed.

    Hub configurationBrowseComp accuracy
    Untuned Qwen3.5-9B with prompting only45.5%
    Qwen3.5-9B + SFT48.0%
    Qwen3.5-9B + SFT + GRPO50.0%
    GPT-5.4 used directly as the hub50.5%

    The first three rows are results from our existing experiments. SFT adds 2.5 percentage points, and GRPO adds 2.0 percentage points from the same SFT checkpoint. When GPT-5.4 performs both writes and reads through the same interface, accuracy reaches 50.5%, 0.5 percentage points above the trained 9B hub. The task-trained 9B hub achieves a similar point estimate to the teacher used directly as the hub.

  2. The communication mechanism also affects accuracy.

    Sharing setupBrowseComp accuracy
    Disable shared writes38.5%
    Keep shared notes and disable on-demand reading41.0%
    Broadcast peers' raw trajectories directly39.0%
    Full AgentFugue50.0%

    When we keep the notes and disable on-demand reading, agents can still see what their peers have explored. They lose the ability to inspect raw evidence for their current question, and accuracy drops by 9.0 percentage points. This comparison motivates the two-level interface. Notes help agents identify findings worth following up, and on-demand reads provide evidence for their next action. Directly broadcasting raw trajectories also performs below the full system, indicating that information selection and organization affect collaboration.

AuthorsOpenReview ↗

[ Part 3/4 ] Rebuttal for Reviewer XmWi

W3: Evidence Sharing

Thank you for pointing out that our wording about the best results in the main table was too broad. You also raised the possibility that weaker models adopt the answers of stronger peers. We clarify the scope of the main comparison and measure how much of the gain remains when explicit answers are masked.

1. The main-table gains are within-backbone comparisons. The table below compares AgentFugue with the strongest evaluated multi-agent baseline for each backbone and benchmark.

BackboneBenchmarkBest same-backbone multi-agent baselineAgentFugueGain (pp)
QwenBrowseComp45.2%50.0%+4.8
QwenWideSearch70.4%72.3%+1.9
QwenHLE32.2%41.0%+8.8
DeepSeekBrowseComp59.0%71.2%+12.2
DeepSeekWideSearch72.7%74.2%+1.5
DeepSeekHLE44.0%49.5%+5.5

The cited Kimi-K2.5 score on HLE is 50.2%, above both AgentFugue configurations. We will revise the paper to specify that AgentFugue achieves the best result among the evaluated same-backbone multi-agent systems for both backbones on all three benchmarks.

2. Evidence and open leads remain useful when explicit answers are masked. Appendix E.1 illustrates how agents use intermediate information. Agent-1 and Agent-2 ultimately answer 1885 and 1848, respectively. At step 34, Agent-0 reads Agent-1's record of ruled-out candidates and a lead about the cloth trade. Agent-0 follows up with a new search and visits a source supporting 1853 at step 37. It reads Agent-2's record later, during cross-checking. The trace shows how the shared information changed the next query and where the evidence for the correct answer came from.

To test this mechanism in a heterogeneous team, we fix the four models, questions, budgets, and local memory settings. We compare independent exploration, sharing with explicit answers masked, and full sharing. The masked condition removes explicit candidate answers from both shared notes and readouts. We score each model's answer before final aggregation.

Sharing setupQwenDeepSeekGLMKimiMean
Independent exploration40%56%44%61%50.3%
Mask explicit answers and retain evidence and leads53%65%55%63%59.0%
Full sharing59%71%59%65%63.5%

With explicit answers masked, mean individual accuracy remains about 8.8 percentage points above independent exploration. This retains roughly two-thirds of the full-sharing gain. Qwen also improves from 40% to 53%. These results support the role of shared evidence and search leads in guiding further exploration. Sharing candidate answers may account for part of the additional gain under full sharing. The gain in the masked condition persists after direct access to explicit answers is removed.

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

This paper proposes a collective reasoning framework called AgentFugue. The main idea is to use a collection of agents to solve long-horizon and complex tasks in a shared reasoning hub. In the reasoning hub, each agent compresses its context (e.g., query, reasoning, tool-calling results) into ``notes'' and exchange notes with other agents to compose its working context; each agent selectively choose notes from others to compose its working context in each iteration based on its own intent and goal.

Test-time scaling with multiple agents is not new but the main contributions of this paper are two-fold: i) model the process as raw episode (raw log) -> episode notes (compressed knowledge) -> selectively composed working context; ii) two key learnable components, M_write (how to compress) and M_read (how to select). Two-stage post-training approaches are used to train the two LLMs M_write and M_read, which are standard but seem to be effective in experiments.

Critical strengths

S1. Formalize a complex system into a simple but concrete framework. The paper model a complex (multi-)agent system in a very clean way with several key learnable roles. The formalization is also general enough (raw log - compression - context selection) and seems to be effective in experiments.

S2. Making M_write and M_read learnable is a useful and generalizable design choice. Effective context compression and composition are clearly important to the system's performance. These two components have large potential to be improved, each requiring quite different capabilities of the model and thus better to be post-trained separately.

Critical weaknesses

W1. A stronger comparison with sampling-and-selection methods would clarify the contribution of shared reasoning. A more careful ablation study needs to be conducted to distinguish between the contributions to the final improvement from better M_write and M_read, those from the agentic framework of reasoning hub, those from different aggregators. For example, there are other test-time scaling approaches, such as Chen et al., Provable Scaling Laws for the Test-Time Compute of Large Language Models, NeurIPS 2025, with non-trivial knockout or league-style aggregation of each agent's answer; the questions are whether a better aggregator requires less-trained M_write and M_read and how much it contributes.

W2. The SFT's goal and the RL stage are insufficiently specified. Context managers, M_write/M_read, post-training methods/goals, and the aggregators are three critical components in the system. However, they are not studied as a whole. It is good to freeze the models behind task agents, but it is unclear, for example, what are distilled from GPT5.4 into M_write and M_read (other than mimicking its outputs). For GRPO, it is unclear how the resulting task reward is attributed to the separate writer M_write and reader M_read instances.

Questions for authors

Q1. Comparison and ablation study on non-trivial aggregators such as those in Chen et al., NeurIPS 2025.

Q2. Appendix A provides SFT settings but insufficient RL details, e.g., coefficients in the reward formula, group size, training schedule and so on.

Q3. An SFT-only versus SFT-plus-GRPO ablation would be helpful establish the benefit of task-level reward optimization beyond imitating the teacher's notes-writing and reading behaviors.

3 comments
AuthorsOpenReview ↗

[ Part 1/3 ] Rebuttal for Reviewer RMUS

Thank you for recognizing that AgentFugue gives a clear formulation of a complex multi-agent system and that its learnable write and read modules are valuable !

W1 / Q1: Aggregation

You asked how stronger answer aggregation affects our estimates of the contributions of the shared framework and its write and read modules. In particular, you asked whether a stronger aggregator can substitute for a fully trained hub. We reimplemented the aggregation methods you suggested and tested them in our setting.

1. Shared exploration and final aggregation operate at different stages.

AgentFugue lets agents use their peers' evidence, ruled-out candidates, and open leads to guide their search while they are still exploring. Knockout and League, proposed in Provable Scaling Laws for the Test-Time Compute of Large Language Models, compare and select candidates after they have been generated. The benefit of a stronger selector therefore depends on what the exploration stage produces.

2. The comparison tests how far stronger aggregation can substitute for shared exploration and hub training.

We evaluate teams of five Qwen3.5-35B-A3B peers on the same 200 BrowseComp questions. We compare independent exploration with shared hubs at different stages of training. We evaluate reimplementations of Knockout and League alongside the original BoN selector.

Exploration setupBoNKnockoutLeague
Independent peers with the same local memory management55.0%56.5%57.5%
AgentFugue with a prompt-only hub59.0%60.5%61.5%
AgentFugue with an SFT hub62.0%63.5%64.5%
AgentFugue with an SFT+GRPO hub64.0%65.5%66.0%
  • Stronger aggregation improves both setups, and shared exploration retains its advantage. Switching from BoN to League raises accuracy from 55.0% to 57.5% for independent peers and from 64.0% to 66.0% for full AgentFugue. With both systems using League, full AgentFugue leads by 8.5 percentage points.
  • Hub training improves accuracy under a fixed aggregator. With League, the prompt-only, SFT, and SFT+GRPO hubs reach 61.5%, 64.5%, and 66.0%, respectively. The full hub leads the prompt-only hub by 4.5 percentage points and the SFT hub by 1.5 percentage points. Across aggregators, SFT + League reaches 64.5%, which is 0.5 percentage points above the 64.0% of SFT+GRPO + BoN. In this setting, League can offset the accuracy gap from omitting GRPO, at the cost of 10 additional judge calls per question.

3. Communication ablations test how information is organized and read.

On BrowseComp, we hold the task agents, tools, context budget, and aggregation rule fixed.

Communication setupBrowseComp accuracy
No write (disable writes of shared episodes)38.5%
No read (retain shared notes and disable intent-conditioned reads)41.0%
Raw broadcast (expose raw trajectories directly)39.0%
Full AgentFugue50.0%

No read preserves shared notes and scores 9.0 percentage points below the full method. Raw broadcast scores 11.0 percentage points below it. The notes give agents an overview of team progress. Reading raw episodes on demand provides details relevant to the agent's current decision. In this comparison, direct access to raw trajectories is less effective than organized, selective access. These ablations test the communication interface. The independent-peer and aggregation comparisons above help distinguish the roles of local memory, cross-peer communication, and final answer selection.

AuthorsOpenReview ↗

[ Part 2/3 ] Rebuttal for Reviewer RMUS

W2 / Q2: Hub Training

We would like to clarify the relevant training details.

1. SFT provides supervision for writing and reading.

As described in §2.3, we collect trajectories from OpenSeeker and OpenResearcher. We filter them by trajectory length and answer correctness, retaining 2,000 trajectories. GPT-5.4 generates targets for both operations.

  • Writing. The input is a complete exploration episode. The target is a note that records useful evidence, directions already explored, and unresolved questions for agents that may use the episode later.
  • Reading. The input is the current intent and the raw content of the referenced episodes. The target is a synthesis of evidence relevant to that intent. The task agent chooses the references using the notes it can see. The reader processes the raw content of those episodes.

The writer learns how to record progress for later use. The reader learns how to turn that progress into information useful to the current task. The task agents remain frozen.

2. GRPO samples at the level of a single write or read operation.

From the same team state, we sample three candidate outputs for one write or read operation. We continue team execution separately with each candidate and compute group-relative advantages from downstream task rewards. The policy loss applies only to the sampled outputs at the point where the rollouts branch. Later write or read operations can be evaluated when they become sampling points.

The writer and reader have separate parameters. We alternate between updating one and freezing the other. The task agents remain frozen throughout, and each module uses its own SFT checkpoint as the KL reference.

ParameterSetting
Maximum training sequence length32K
Candidate group size3
Learning rate10^(-6)
GRPO clipping parameter / KL coefficient0.2 / 0.02
Per update8 state groups, 24 candidates total
Training budget200 updates, 100 each for reading and writing
AuthorsOpenReview ↗

[ Part 3/3 ] Rebuttal for Reviewer RMUS

Q3: RL Benefit

In response to your question about SFT-only versus SFT+GRPO, we compared three training stages while keeping the communication framework and final aggregation rule fixed.

1. We vary the hub's training stage under a fixed communication and aggregation setup.

All three configurations use the same Qwen3.5-9B hub backbone, task agents, tools, context budget, and answer aggregation rule. The prompt-only hub uses the base model without task-specific tuning. The SFT-only hub uses the supervised checkpoint. The full hub adds GRPO.

Hub configurationBrowseComp accuracy
Prompt-only45.5%
SFT-only48.0%
SFT+GRPO50.0%

2. GRPO adds an improvement over SFT.

SFT improves accuracy by 2.5 percentage points over the prompt-only hub. GRPO adds 2.0 percentage points on top of SFT. The communication interface, task agents, and aggregation rule are fixed, so this difference measures the added effect of optimizing the hub with downstream task feedback.

Teacher supervision provides a starting point for writing and reading. Further optimization with task feedback improves performance within the same framework.

We hope these results and clarifications address your questions. We would be happy to provide further details or respond to any follow-up questions.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.