acceptodds
Under review as a conference paper at ICLR 2027

Muffin - A shared memory buffer for collaborative AI agents

Abstract

The rise of Agentic AI systems has changed the landscape of artificial intelligence by enabling strong reasoning capabilities through specialized multi-agent interaction with structured self-reflection. However, in target-driven reasoning tasks, single- and multi-agent systems are often on par in terms of performance gains. A major challenge is that failures often arise from an ineffective exchange of critical information during inter-agent interaction and coordination. Different from existing multi-agent debate paradigms that rely on synchronous turn-taking and sharing information across different agents, we propose an inter-agent protocol based on shared emory ber ference - referred to as - in an asynchronous agentic framework. In the first step, an orchestrator routes queries based on their reasoning demands and delegates demanding ones to a multi-agent setting, where a shared memory buffer provides asynchronous exchange of intermediate findings while an agent's private reasoning remains local. Our experiments show that our framework Muffin outperforms established competitors, achieving the best accuracy in 17 out of 20 of our benchmark settings, and provides a better quality-cost trade-off than multi-agent debate: Muffin improves accuracy by 19.2 accuracy points while using 77.4% fewer tokens, without requiring full-trace sharing.

Primary area:
foundation or frontier models, including LLMs
Keywords:
agentic AI, multi-agent reasoning

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_WxDHOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The authors present a collaborative multi-agent framework "Muffin" based on the use of a shared buffer. From my understanding their method roughly works as follows:

  1. An "orchestrator" LLM reads the question and decides if it answers directly or if it needs a team. In the latter case, it will spawn 2-3 subagents and assign those subagents precise roles/subtasks
  2. Each agent then runs for a fixed number of steps. At each step, the agent reads the kk most recent notes left in the buffer and performs its reasoning. The model then produces i) a short summary for itself mm ii) what (if anything) it will write in the buffer denoted ss iii) private notes nn
  3. Once all reasoning is finished, a summarizer agent takes as input the question + every agent's final summary and picks the best answer

The method is asynchronous in the number of steps. An agent doesn't wait for another to finish, it just reads from the buffer when its next step starts. If a note lands mid-step, it is only seen at the next step.

The authors empirically validate their method on multiple benchmarks (MMLU, GPQA, OlymMath, Chess) and show that their method outperforms majority voting and multi-agent debate baselines across 17/20 of their selected benchmarks.

All in all I think the paper is interesting and the method is promising, but I find that their headline numbers overclaim a bit. I would raise my score if

  • The authors include (at least) one novel baseline based on a different cooperative protocol
  • The authors either revise/remove the token count reduction claim or make it in a fairer scenario (see weakness 2 for more details)
Critical strengths
  • The method is simple, interesting and seems to work rather well. I believe the approach to be promising work.

  • The authors provide many ablations allowing the reader to better understand the method and which parts of it are most crucial to its success.

Critical weaknesses

Critical weakness 1: the authors do not evaluate their method against any other cooperative multi-agent systems.

  • This makes it hard to determine if the collaborative approach of their method is the driving factor in their accuracy results. It would be interesting to see how their method stacks up against e.g. GroupThink (https://arxiv.org/abs/2505.11107), Mixture-of-agents (https://arxiv.org/abs/2406.04692)
  • Relatedly, https://arxiv.org/abs/2510.13903 studies the agent-count vs. communication-bandwidth trade-off and should be discussed in related work, since it directly relates to the results in Fig 4 and Fig 6.

Critical weakness 2: the claim on token reduction feels cherry picked

  • By design, Muffin forces summarization and reads from a small sized buffer which reduces total token count. The multi-agent debate protocol proposed by Du et al. has every agent see the full previous responses of all other agents at each round which by design would inflate token count. This feels like an unfair comparison. Thus, I find the headline "Muffin improves accuracy by 19.2 accuracy points while using 77.4% fewer tokens, without requiring full-trace sharing" to be quite misleading.
  • Moreover, in Figure 3, it can be seen that both single agent and majority vote baselines require far less tokens than Muffin for the same "step" count.
  • It could be interesting to either: i) report token efficiency only via generation/CoT (see related question) which would make the comparison more fair ii) compare token efficiency to one of the baselines mentioned above.
Questions for authors
  • What roles/strategies/subtasks the agents typically end up using for the problem decomposition? I am curious how this changes across task domains also.
  • Would it be possible to show a version of Table 1 which includes token counts?
  • Would be interesting to see how performance changes when a larger model is used as orchestrator but the subagents are still rather small
  • How do token efficiency results hold up if one looks only at output (e.g. CoT/generation) tokens, not input + output?
  • What is the default value of kk used across experiments?
5 comments

Question 1: Role choice from the orchestrator

We analyze the orchestrator-generated roles from Muffin runs in Table 1 on five benchmarks and four backbone models, with three agents and five reasoning steps per agent. In this experiment setting each team consists of three agents, one of which is always a Critic as required by the orchestrator's prompt, and the other two are chosen depending on the domain. The table below shows the share of each functional role among the agents assigned by the orchestrator. And here are the descriptions and examples of how we cluster the agents’ roles:

  1. Critic: It challenges the other agents’ findings and points out errors or missing cases. By design, the orchestrator’s prompt requires including one Critic in every team, since prior work has shown that debate between agents improves reasoning accuracy
  2. Modeler: It builds a structured representation of the problem that the other agents work on. Chess: (BoardStateReconstructor, GameSimulator); OlymMATH: (GeometricSetupAgent, GeometricModeler); GPQA: (SynthesisArchitect, StructuralMapper); MMLU-Pro: (FinancialModeler).
  3. Solver: It carries out the main computation task. Chess: (MoveGenerator, LegalMoveGenerator); OlymMATH: (AlgebraicDeriver, CombinatorialCounter); GPQA: (EnergyCalculator, StoichiometryAgent); MMLU-Pro: (FinancialCalculator, CalculationAgent).
  4. Domain expert: It is specialized to the subfield of each question. OlymMATH: (CoordinateGeometrySpecialist, CombinatorialAnalyst); GPQA: (ReactionMechanist, ReactionMechanismExpert); MMLU-Pro: (FinancialAnalyst, LinguisticAnalyst).
  5. Verifier: It checks if the result is consistent with the rules of the problem. Chess: (MoveValidator, MoveLegalityChecker); OlymMATH: (ConstraintVerifier, GeometricVerifier); GPQA: (NomenclatureVerifier, StructuralVerifier); MMLU-Pro: (VerificationAgent, VerificationAuditor).
  6. Option analyst: It matches the result to the given answer choices and removes the wrong ones, it only appears in the multiple-choice benchmarks. GPQA: (OptionMappingAuditor); MMLU-Pro: (OptionMatcher).
BenchmarkCriticVerifierModelerSolverDomain expertOption analystOther
OlymMATH-E33.310.710.332.013.30.00.4
OlymMATH-H33.39.98.630.117.40.00.7
GPQA33.39.77.815.230.72.90.3
MMLU-Pro33.311.76.021.015.512.40.1
Chess33.327.735.43.40.00.00.2

Question 2: Table 1 with token counts

This table reports the mean number of input and output tokens per task. We also take the average over the five benchmarks and compare the total token usage with Muffin.

ModelMethodChess InChess OutGPQA InGPQA OutMMLU-Pro InMMLU-Pro OutOlymMATH-E InOlymMATH-E OutOlymMATH-H InOlymMATH-H OutAvg. InAvg. OutAvg. Total×Muffin
gemma-4-E4B-itSingle-Agent2.41.55.34.84.52.65.18.16.18.24.75.09.70.16×
Majority Vote7.34.416.014.213.67.816.124.917.725.014.115.229.40.48×
Multi-Agent Debate8.90.6108.812.060.36.4209.123.6219.023.8121.213.3134.52.20×
Muffin15.632.918.840.011.713.416.966.017.473.416.145.161.21.00×
gemma-4-31B-itSingle-Agent2.31.03.63.43.61.87.413.17.612.54.96.411.30.32×
Majority Vote6.93.211.09.510.75.322.438.422.338.314.718.933.60.96×
Multi-Agent Debate32.15.977.110.852.07.4140.118.1181.121.296.512.7109.13.11×
Muffin15.65.121.010.720.96.720.421.522.331.420.015.135.11.00×
Qwen3.5-4BSingle-Agent60.377.925.748.711.225.135.464.746.472.035.857.793.50.40×
Majority Vote181.2233.877.0146.133.575.2105.9193.9140.0216.4107.5173.1280.61.19×
Multi-Agent Debate1277.4213.3970.7174.6711.4150.3791.6108.11062.1195.3962.6168.31130.94.79×
Muffin45.2264.232.3175.426.2113.425.1217.335.8245.532.9203.1236.01.00×
Qwen3.8-27BSingle-Agent3.230.113.235.05.58.49.934.021.653.810.732.242.90.30×
Majority Vote9.790.239.8104.816.625.129.7102.264.7161.332.196.7128.80.89×
Multi-Agent Debate426.852.1423.547.7153.217.2553.863.4985.0134.1508.462.9571.33.95×
Muffin25.5117.626.999.923.840.428.2150.227.0183.826.3118.4144.71.00×

Question 3: Use a large model for the orchestrator and summarizer, and for subagents use a small model

This is an interesting suggestion, and we will run an experiment on OlymMATH-E. In this setting, only the orchestrator and the summarizer use the larger gemma-4-31B-it, with all subagents using the smaller gemma-4-E4B-it. We compare this with results from the Gemma-4 model family, where all components use the same model. This setting raises accuracy from 59.3% to 63.0%, while total token cost stays nearly the same as using only the small model. The smaller model uses about 3x more output tokens per task, mostly on private thinking, while its shared summaries are shorter, which is why the summarizer’s input is smaller. The gap with only using a 31B model is still large, showing that the sub-agents’ reasoning capacity is the main bottleneck.

Orchestrator / SummarizerSubagentsAccuracyOrchestrator tokens (in/out)Summarizer tokens (in/out)Subagent tokens (in/out)Total tokens
gemma-4-E4B-itgemma-4-E4B-it0.593 ± 0.0120.9k / 1.9k1.8k / 0.7k14.5k / 64.7k84.5k
gemma-4-31B-itgemma-4-E4B-it0.6300.9k / 0.8k1.8k / 0.5k14.3k / 67.2k85.5k
gemma-4-31B-itgemma-4-31B-it0.850 ± 0.0100.9k / 0.8k4.3k / 0.5k15.2k / 20.1k41.9k

Question 4: How do token efficiency results hold up if we only look at the completion token

Here we report input and output tokens separately for both Multi-Agent Debate and Muffin. The 77.4% token reduction stated in the paper comes from a single 10-step run on OlymMATH-E with gemma-4-E4B-it, so it may not generalize. We instead use the average over all runs reported in Table 1, which includes 4 models x 5 benchmarks, and got a similar result of 74.3% fewer total tokens. The results are shown in the table below. On output tokens alone, Muffin generates 1.6x more than Debate. This is expected from the orchestrator, the structure step’s format, and the summarizer. On the other hand, Muffin uses 16.7x fewer input tokens because we have a compact prompt format. If we consider this as cost, the commercial API usually prices output tokens at about 4-5x input tokens. Under this weighting, Muffin is still around 30% cheaper than Multi-agent Debate overall.

DebateMUFFINMUFFIN vs. Multi-Agent Debate
Input403.9k24.1k94.0% fewer (16.7×)
Output59.5k95.0k59.6% more (1.60×)
Total463.4k119.1k74.3% fewer (3.9×)
Cost (output = 4× input)641.9k404.0k37.1% cheaper
Cost (output = 5× input)701.4k498.9k28.9% cheaper

Question 5: What is the default of k?

We use k=10k = 10 by default in all experiments, so each agent is able to read the 10 most recent findings of other agents from the memory buffer. The only exception is the ablation on the number of shared findings we report in Section 4.3, where we set k∈5,10,15k \in \\{5, 10,15\\}.

Weakness 1: No comparison against other cooperative multi-agent systems.

We thank the reviewer for this suggestion. We are adding Learning to Share (LTS)[1] as a new baseline, suggested by another reviewer, since it is the cooperative protocol closest to Muffin. We will discuss more to distinguish our work from Group Think, Mixture-of-Agents and LTS. We will add the reference you provided to the related work [2].

vs. Groupthink

Group Think runs one LLM as several thinkers that see each other’s partial generations token by token. Agents therefore share their full traces, and the method needs a modified decoding loop. Muffin agents share only the findings they choose to publish, and Muffin runs on any standard serving engine.

vs. Mixture-of-agents

MOA is layer-synchronous, each agent needs to wait for and read the complete responses of all agents in the previous layer. Muffin agents run asynchronously and exchange compact findings during reasoning rather than full responses after it.

vs. LTS

LTS and Muffin both share intermediate information, but they differ in what is parallelized and who controls the sharing. LTS runs K independent teams (same prompt, same agent) in parallel. Within each team, the execution remains sequential. After each worker's step, a learned controller decides whether to store the raw output, and only each team’s orchestrator can read the memory, using LLM call to select keys. Muffin instead parallelizes within a single team of agents with roles and subtasks defined by the orchestrator. And sharing is controlled by the agent itself, which is part of the generation, with no extra training or selection calls.

This table summarizes the key design differences between Muffin and the related approaches.

MethodShared MemoryAsyncQuery-adaptive team designTraining-freeStandard serving engine
Mixture-of-AgentsPrevious-layer responses✖✖✓✓
Group ThinkToken-level traces✓✖✓✖
LTSCross-team✓✖✖✓
MuffinWithin-team✓✓✓✓

LTS as a Baseline

We evaluate LTS in our problem setting using the authors’ released code and their pretrained memory controller, and use the same backbone model as Muffin. Since our benchmarks are closed-book, we removed the WebSurfer agent from each team, leaving all other components unchanged. We first provide the comparison on the OlymMATH-E benchmark with gemma-4-31B-it. We also compare against two variants of LTS proposed in their paper. LTS-LLM replaces the trained controller with an LLM-as-a-judge that decides what to store, and LTS-AddAll stores everything in the shared memory without any filtering. As shown in the table below, Muffin achieves higher accuracy than all LTS variants while using fewer tokens in total. We also see that the trained memory controller version is a bit worse than the LLM-as-a-Judge heuristic. This might be because the controller was trained on AssistantBench, a tool-intensive web task, and may not transfer to reasoning tasks without retraining.

MethodAvg. AccuracyAvg. Input TokenAvg. Output Token
LTS82.5 ± 0.021115.9K19.3K
LTS-LLM84.0 ± 0.014108.7K18.7K
LTS-AddAll82.0 ± 0.021107.6K18.1K
Muffin85.0 ± 0.01020.4K21.5K

References

[1] Fioresi, J., Kulkarni, P. P., Vayani, A., Wang, S., and Shah, M. Learning to Share: Selective Memory for Efficient Parallel Agentic Systems. Proceedings of the 43rd International Conference on Machine Learning. https://proceedings.mlr.press/v306/fioresi26a.html

[2] Michael Rizvi-Martel, Satwik Bhattamishra, Neil Rathi, Guillaume Rabusseau, Michael Hahn. Benefits and Limitations of Communication in Multi-Agent Reasoning. https://arxiv.org/abs/2510.13903

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

This paper introduces Muffin, an inter-agent protocol based on shared memory buffer inference in an asynchronous agentic framework. The framework consists of an orchestrator that routes queries based on their reasoning demands and delegates demanding ones to a multi-agent setting, a shared memory buffer that provides asynchronous exchange of intermediate findings while an agent’s private reasoning remains local, and a summarizer which produces the final response based on the final messages from each agent along the agents’ meta information and the initial user query. The authors show that Muffin outperforms established competitors, achieving the best accuracy in 17 out of 20 benchmark settings, and provides a better quality-cost trade-off than multi-agent debate. Muffin also improves accuracy by 19.2 accuracy points while using 77.4% fewer tokens.

Critical strengths
  1. Sound method and clear writing - The authors provide a sound description of their method and the writing is easy to understand
  2. Good results - The results presented by the authors are promising and show general improvement over baselines with increased token efficiency
Critical weaknesses
  1. Limited novelty - Even though the framework is interesting, the use of shared memory buffer for agentic frameworks is an explored concept. Methods like M1-Parallel[1] and LTS[2] have used global/shared memory for parallel agentic execution, while GMemory[3] explores hierarchical memory. Papers like MDAgents[4] and MedRoute[5], although do not explicitly use a shared memory buffer, have explored passing on history and using it for decision making. MDAgents also involves deciding the difficulty of the problem (in more granular fashion) which is what the Orchestrator does in the proposed framework
  2. Choice of memory input unclear - How does the framework decide what goes into the memory buffer is not discussed
  3. Comparison to baselines and SoTA limited - Comparisons to previously mentioned methods is necessary for understanding the effect of the proposed approach. Also testing the method only on two families of models makes the analysis less general.
  4. Validation set sampling strategy absent - The authors mention that 100 data points are sampled from datasets for analysis. However, the sampling methods are not discussed. Also for large datasets like MMLU-Pro with more than 10k samples, 100 samples might not give the best representation of the same.

[1] Zhang, E., Zhu, E., Bansal, G., Fourney, A., Mozannar, H., and Gerrits, J. Optimizing sequential multistep tasks with parallel llm agents. arXiv preprint arXiv:2507.08944, 2025a.

[2] Fioresi, J., Kulkarni, P., Vayani, A., Wang, S., and Shah, M. Learning to Share: Selective Memory for Efficient Parallel Agentic Systems, Proceedings of the 43rd International Conference on Machine Learning, 2026

[3] Zhang, G., Fu, M., Wang, K., Wan, F., Yu, M., and Yan, S. G-Memory: Tracing Hierarchical Memory for Multi-Agent Systems, Advances in Neural Information Processing Systems, 2025.

[4] Kim, Y., Park, C., Jeong, H., Chan, Y. S., Xu, X., McDuff, D., Lee, H., Ghassemi, M., Breazeal, C., and Park, H. W. Mdagents: An adaptive collaboration of llms for medical decision-making. Advances in Neural Information Processing Systems, 2024.

[5] Vayani, A.; Kulkarni, P.P.; Fioresi, J.; Wang, S.; Shah, M. MedRoute: RL-Based Dynamic Specialist Routing in Multi-Agent Medical Diagnosis. arXiv 2026, arXiv:2604.06180

Questions for authors

Clarification

  1. How were backbone models chosen (Gemma/Qwen)? It would be interesting to see an analysis of how different models perform on these benchmarks.
5 comments

Weakness 1: Limited novelty

We thank the reviewer for these references, and we will discuss them in the related work. We agree that memory and history sharing have been explored in agentic systems. Our problem setting is slightly different from theirs; we focus on memory shared at runtime among agents in the same team while they solve the same task, and we will clarify how Muffin differs from them.

vs. M1-Parallel / LTS

M1-Parallel runs several teams in parallel and combines their final answers, and the teams do not share memory. LTS adds memory shared across these teams, with a trained memory controller deciding what to store. Muffin instead runs in parallel inside one team, each agent has a different role, and they can decide what to publish, with no training.

vs. G-Memory

G-Memory accumulates memory across tasks so the system can improve over time. Muffin’s buffer exists only while a single task is running.

vs. MDAgents / MedRoute

Both target the medical domain. MDAgents shares the conversation from earlier discussion rounds with all agents, while MedRoute passes the diagnosis history sequentially from one specialist to the next through a trained router. In Muffin, agents read each other’s partial findings while their own reasoning is still running, and the framework is not tied to a specific domain. We agree that MDAgents’ three-level complexity assessment is related to our routing step, but routing is not our main contribution. Our orchestrator mainly assigns roles and subtasks.

The table below summarizes the key design differences between Muffin and the related approaches.

MethodShared MemoryAsyncQuery-adaptive team designTraining-freeDomain-general
M1-Parallel✖✖✖✓✓
MDAgentsDiscussion rounds✖✓✓✖
MedRouteSequential history✖✓✖✖
G-memoryCross-task-✖✓✓
LTSCross-team✓✖✖✓
MuffinWithin-team✓✓✓✓

LTS as a Baseline

We evaluate LTS in our problem setting using the authors’ released code and their pretrained memory controller, and use the same backbone model as Muffin. Since our benchmarks are closed-book, we removed the WebSurfer agent from each team, leaving all other components unchanged. We first provide the comparison on the OlymMATH-E benchmark with gemma-4-31B-it. We also compare against two variants of LTS proposed in their paper. LTS-LLM replaces the trained controller with an LLM-as-a-judge that decides what to store, and LTS-AddAll stores everything in the shared memory without any filtering. As shown in the table below, Muffin achieves higher accuracy than all LTS variants while using about 3× fewer tokens in total. We also see that the trained memory controller version is a bit worse than the LLM-as-a-Judge heuristic. This might be because the controller was trained on AssistantBench, a tool-intensive web task, and may not transfer to reasoning tasks without retraining.

MethodAvg. AccuracyAvg. Token Usage
LTS82.5 ± 0.021135.2K
LTS-LLM84.0 ± 0.014127.4K
LTS-AddAll82.0 ± 0.021125.7K
Muffin85.0 ± 0.01041.9K

Weakness 2: Choice of the shared findings

The finding written to the memory buffer is described in Section 3, each agent step outputs a summary, an optional shared finding Si(t)S_i^{(t)}, and private notes. Only Si(t)S_i^{(t)} will be written into the buffer, which is decided by the LLM, and it can also choose not to provide any shared finding in this step.

Weakness 4: Benchmark sampling strategy

We agree that 100 examples give limited coverage of MMLU-Pro, this is because we follow the 100-example evaluation setting of prior work for fair comparison (Multi-agent debate, ICML'24)[1] and also due to a lack of compute resources.

References

[1] Yilun Du, Shuang Li, Antonio Torralba, Joshua B. Tenenbaum, and Igor Mordatch. Improving factuality and reasoning in language models through multiagent debate. Proceedings of the 41st International Conference on Machine Learning. https://proceedings.mlr.press/v235/du24e.html

Question 1: Backbone model

We chose recent open-weight model families (Gemma-4 and Qwen3.5/3.8) because our goal is to test whether Muffin improves reasoning on current LLMs. For each family, we choose a small size (around 4B) and a large one (around 30B), so we can see the effect across model scale. To check other model families, we additionally ran Phi-4-mini-reasoning on OlymMATH-E. The results are shown in the Table below, and the pattern matches the other backbones.

MethodPhi-4-mini-reasoning
Single-Agent0.310 ± 0.010
Majority Vote0.390 ± 0.010
Multi-Agent Debate0.430 ± 0.010
Muffin0.467 ± 0.021

Dear Reviewer,

We hope our response has addressed your concerns. As the author–reviewer discussion period ends soon, we would be grateful if you could let us know whether you have any remaining questions that we can further clarify. If our response has resolved your concerns, we would kindly ask you to consider reflecting this in your evaluation.

Thank you! The author

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

This paper proposes Muffin, a multi-agent reasoning framework that enables asynchronous collaboration through a shared memory buffer. An orchestrator dynamically assigns specialized roles and subtasks to agents, which independently execute reasoning steps while publishing selected intermediate findings to an append-only shared buffer. At each step, agents retrieve recent findings from other agents without exposing their complete reasoning traces, and a final summarizer aggregates their outputs. Experiments across four language models and five benchmark subsets show that Muffin achieves the highest accuracy in 17 out of 20 settings, while demonstrating favorable accuracy-token trade-offs compared to multi-agent debate and full-trace sharing approaches. The paper further analyzes how shared findings affect agent predictions and how retrieval budgets influence reasoning performance.

Critical strengths

1. Consistent empirical improvements across models and reasoning benchmarks. Muffin achieves the highest accuracy in 17 out of 20 model-benchmark settings, with particularly substantial improvements on mathematical reasoning tasks. The evaluation spans four language models from two model families and multiple reasoning domains. These results provide encouraging evidence that the overall framework is effective and that its benefits are not limited to a single model or benchmark.

2. A practical approach to improving the accuracy-efficiency trade-off in multi-agent reasoning. The framework offers a lightweight communication mechanism that exchanges concise intermediate findings rather than complete reasoning traces. The accuracy-token analyses and the shared-finding analyses, provide useful empirical evidence that selective communication can reduce context overhead while maintaining competitive reasoning performance. This makes the approach potentially valuable for resource-efficient multi-agent systems, even if the novelty of its individual components requires further justification.

Critical weaknesses

1. Limited methodological novelty and insufficient differentiation from closely related work. The proposed framework appears to combine several previously explored multi-agent communication mechanisms, and its methodological novelty relative to existing work is not sufficiently established. In particular, several closely related approaches have already investigated shared intermediate information, selective memory, and early communication between agents, but are either missing from the related work discussion or not adequately distinguished.

  • Learning to Share (LTS, ICML 2026) [1] introduces a global shared-memory bank that allows parallel agent teams to selectively share and reuse intermediate results, explicitly targeting communication efficiency and redundant computation. This substantially overlaps with Muffin's central motivation of improving efficiency through selective intermediate information sharing. Furthermore, LTS uses a learned memory-admission controller, whereas Muffin relies on prompt-based finding selection and recency-based retrieval. While LTS focuses on cross-team reuse rather than intra-team collaboration, the conceptual overlap is substantial, and the absence of a discussion of this work is concerning.

  • Blackboard-based Multi-Agent Systems (Han and Zhang, 2025) [2] already investigate specialized agents collaborating through a shared information space, with agents repeatedly incorporating information from the blackboard during problem solving. This is architecturally similar to Muffin's shared-buffer-based collaboration. Although Muffin introduces independently scheduled reasoning steps and an append-only buffer, the paper does not establish why these particular design choices constitute a substantial methodological advance over existing blackboard-based coordination.

  • Streaming Communication in Multi-Agent Reasoning (StreamMA, 2026) [3], which Muffin already cites, similarly addresses the limitations of waiting for complete agent outputs by enabling intermediate reasoning steps to be communicated during execution. While StreamMA uses pipelined communication rather than a shared buffer, it provides closely related motivation and evidence for the benefits of early intermediate information exchange. Muffin does not sufficiently distinguish its claimed contributions from this line of work.

More fundamentally, Muffin's core mechanism is relatively straightforward: agents generate concise findings through prompting, append them to a shared buffer, and retrieve the most recent kk findings at subsequent reasoning steps. The framework does not introduce a learned information-selection mechanism or a principled retrieval strategy, and the paper provides limited insight into why this particular communication protocol should be preferable to existing alternatives. As a result, its main contribution appears to be a specific combination of established mechanisms rather than a clearly differentiated methodological advance.

The experimental evaluation further limits the ability to assess this contribution. The baselines are restricted to Single-Agent, Majority Vote, and Multi-Agent Debate, without comparisons to more closely related shared-memory or intermediate-communication approaches. The insufficient differentiation from prior work, together with the lack of relevant comparisons, makes it difficult to assess the originality and significance of Muffin's claimed contributions.

2. Insufficient experimental evidence to isolate the contributions of shared memory and asynchronous collaboration. Although Muffin achieves promising empirical results, the experiments do not adequately isolate the mechanisms responsible for these improvements. The framework combines several components, including role specialization, asynchronous execution, shared-memory communication, and final summarization, but the existing baselines differ along multiple dimensions. Most importantly, the paper lacks controlled ablations comparing Muffin without shared memory and a synchronous variant with otherwise identical components. Without these comparisons, it remains unclear whether the reported gains stem from the proposed communication mechanism or other architectural choices. Furthermore, Figure 3 shows a substantial accuracy improvement from 44.9% to 59.2% after summarization, raising concerns about the summarizer's contribution to the overall gains.

References

[1] Fioresi, J., Kulkarni, P. P., Vayani, A., Wang, S., and Shah, M. Learning to Share: Selective Memory for Efficient Parallel Agentic Systems. Proceedings of the 43rd International Conference on Machine Learning (ICML), 2026. https://proceedings.mlr.press/v306/fioresi26a.html

[2] Han, B., and Zhang, S. Exploring Advanced LLM Multi-Agent Systems Based on Blackboard Architecture. arXiv preprint arXiv:2507.01701, 2025. https://arxiv.org/abs/2507.01701

[3] Yang, Z., Xu, X., Wang, W., Chen, C., Xu, X., and Chen, Y.-C. Streaming Communication in Multi-Agent Reasoning. Proceedings of the 2026 Conference on Empirical Methods in Natural Language Processing (EMNLP), 2026. https://aclanthology.org/2026.emnlp-main.244/

Questions for authors
  1. What is the fundamental contribution of Muffin relative to existing shared-memory multi-agent frameworks, particularly Learning to Share (ICML 2026) and blackboard-based multi-agent systems? Beyond the specific combination of append-only storage, recency-based retrieval, and asynchronous scheduling, what new capability or insight does Muffin establish that is not already captured by these approaches?

  2. Can the authors provide controlled comparisons of (a) Muffin without shared-memory communication and (b) synchronous Muffin with identical shared-memory functionality, while keeping agent roles, reasoning steps, and summarization procedures fixed?

5 comments

Question 1: Limited methodological novelty

We thank the reviewer for pointing out these works. We will add them to the related work section, and we will clarify how Muffin differs from them.

The core contribution:

Muffin enables a capability that none of these approaches provide: agents within the same team/group can react to each other’s partial findings while their own reasoning is still ongoing, without waiting for peers to finish a response or a reasoning round to terminate. In Muffin, each agent decides at every reasoning step what is worth publishing, and every agent progresses on its own schedule.

vs. LTS.

LTS and Muffin both share intermediate information, but they differ in what is parallelized and who controls the sharing. LTS runs K independent teams (same prompt, same agent) in parallel. Within each team, the execution remains sequential. After each worker's step, a learned controller decides whether to store the raw output, and only each team’s orchestrator can read the memory, leveraging an additional LLM call for selecting relevant information. In contrast, Muffin parallelizes within a single team of agents with roles and subtasks defined by the orchestrator. And sharing is controlled by the agents themself, with no extra training or additional selection calls.

vs. Blackboard MAS (LbMAS)

Both use a shared space that agents can read and write, but differ in how agents are scheduled and how much information each agent consumes. In LbMAS, execution proceeds in synchronous rounds. In each round, the LLM control unit reads the entire blackboard and selects which agent to execute next. Each selected agent then takes the whole blackboard, replacing private memory, and requires a dedicated cleaner agent to delete redundant entries, which adds extra LLM calls. Muffin on the other hand, plans the team only once at the start, after which agents act independently without per-round scheduling. Each agent keeps a private history and publishes only a compact finding, separated from its local notes, and reads only the k most recent findings from peers. Although LbMAS is the most closely related approach, its code has not been released, so we could not include it as a baseline.

vs. StreamMA

StreamMA shares our motivation that agents should not wait for complete outputs, and its findings support our design. It shows that early reasoning steps are more reliable and can improve both latency and accuracy. This matches our observation we report in the Hypothesis 3 section. We therefore view StreamMA as evidence for early information exchange rather than a competing shared-memory approach.

The following table summarizes the key design differences between Muffin and the most closely related approaches.

MethodShared MemoryAsyncMulti-round DebateSelective SharingQuery-adaptive Team DesignTraining-free
Multi-agent Debate✖✖✓✖✖✓
LTS✓✓✖✓✖✖
Blackboard (LbMAS)✓✖✓✖✓✓
Muffin✓✓✓✓✓✓

LTS as a Baseline

We evaluate LTS in our problem setting using the authors’ released code and their pretrained memory controller, and use the same backbone model as Muffin. Since our benchmarks are closed-book, we removed the WebSurfer agent from each team, leaving all other components unchanged. We first provide the comparison on the OlymMATH-E benchmark with gemma-4-31B-it. We also compare against two variants of LTS proposed in their paper. LTS-LLM replaces the trained controller with an LLM-as-a-judge that decides what to store, and LTS-AddAll stores everything in the shared memory without any filtering. As shown in the table below, Muffin achieves higher accuracy than all LTS variants while using about 3× fewer tokens in total. We also see that the trained memory controller version is a bit worse than the LLM-as-a-Judge heuristic. This might be because the controller was trained on AssistantBench, a tool-intensive web task, and may not transfer to reasoning tasks without retraining.

MethodAvg. AccuracyAvg. Token Usage
LTS82.5 ± 0.021135.2K
LTS-LLM84.0 ± 0.014127.4K
LTS-AddAll82.0 ± 0.021125.7K
Muffin85.0 ± 0.01041.9K

Question 2: Controlled ablation

Following the reviewer’s suggestion, we isolate the effects of shared-memory communication and asynchronous execution on OlymMATH-E with gemma-4-31B-it, using 3 agents and 5 reasoning steps per agent. We keep the orchestrator and its role assignment, number of agents, reasoning steps, and the summarizer fixed. All results are averaged over 3 independent runs. We vary only one component at a time: (a) w/o shared memory, where agents never read the buffer, and (b) synchronous, where agents start their reasoning step t+1t + 1only after all agents have finished step tt.

  1. Ablation of Muffin without shared memory: Removing shared-memory communication lowers the accuracy from 85.0% to 83.3% and also increases the standard deviation, as shown in the table below. It shows that without shared findings, each agent reasons in isolation, and the final outcome depends more heavily on whether the agents can reach the correct answer on their own. Sharing findings can improve both accuracy and consistency across runs, but it needs more tokens to retrieve findings in each agent’s context.

  2. Ablation of synchronous Muffin: Synchronous execution reaches similar accuracy to Muffin, but is worse in both cost and latency. It requires 11% more tokens, since every agent waits until all peers have sent their findings, which makes each agent’s context longer. On the other hand, it also takes 10% more wall-clock time per task, due to the waiting time at each step. Asynchronous execution has similar accuracy while avoiding the extra cost and latency introduced by the synchronization.

MethodAvg. AccuracyAvg. TokenAvg. Time (s)
Muffin w/o shared memory83.3 ± 0.03136.7K129.6
Muffin synchronous84.7 ± 0.02146.7K139.9
Muffin85.0 ± 0.01041.9K126.9

Weakness 2: The contribution of the summarizer (Figure 3, 44.9% -> 59.2%)

Thanks for pointing this out. The jump in Figure 3 is a measurement effect, and it only happens in the OlymMATH benchmark, on both the Easy and Hard subsets. This is because the step-wise curve counts an answer as correct only if a majority of agents provide an exactly matching string, and the final point is graded by the benchmark’s equivalence-based scorer. To isolate the contribution from the summarizer, we take a majority vote over the agents’ output that the summarizer will receive and grade it with the same equivalence scorer. Of the 14.3 points gap in Figure 3, 8.2 points come from the scoring mismatch, while the summarizer itself adds 6.1 points.

OutputAccuracy (%)
Majority + exact string match (as in Fig. 3)44.9
Majority + equivalence scorer53.1
Summarizer + equivalence scorer59.2

Dear Reviewer,

We hope our response has addressed your concerns. As the author–reviewer discussion period ends soon, we would be grateful if you could let us know whether you have any remaining questions that we can further clarify. If our response has resolved your concerns, we would kindly ask you to consider reflecting this in your evaluation.

Thank you! The author

Comments on the paper

1 comment

We would like to thank all reviewers for their precious time and providing thoughtful feedback on our paper. The reviewers acknowledge the strengths of our paper: “consistent empirical improvements across models and reasoning benchmarks” (Rev. yqGQ), with results that are “promising and show general improvement over baselines with increased token efficiency” (Rev. i1oD), “a practical approach to improving the accuracy-efficiency trade-off” (Rev. yqGQ), a method that is “simple, interesting and seems to work rather well” (Rev. WxDH), and a “sound method and clear writing” (Rev. i1oD).

During the rebuttal, we tackled the following major concerns raised by the reviewers:

  1. Limited novelty (Rev. i1oD, yqGQ, WxDH): We clarified how Muffin differs from related work (LTS, Blackboard MAS, StreamMA, Group Think, Mixture-of-Agents, etc.) and added a comparison table.
  2. Missing baselines (Rev. i1oD, yqGQ, WxDH): We added LTS and two of its variants. Muffin is more accurate than all of them and uses about 3× fewer tokens.
  3. Unfair token claim (Rev. WxDH): We reported input and output tokens separately, averaged over all settings. Muffin still uses 74% fewer tokens and is about 30% cheaper than Debate.
  4. Missing ablations (Rev. yqGQ): We added versions without shared memory and with synchronous execution. They show that shared memory improves accuracy, and asynchrony saves time.
  5. Summarizer contribution (Rev. yqGQ): We showed that most of the jump in Fig. 3 comes from the scoring method, not from the summarizer.
  6. Limited generality (Rev. i1oD): We added a third model family (Phi-4) and found the same trend.
  7. Memory buffer and sampling (Rev. i1oD): We explained how agents choose what to share. We also explained that we follow the 100-example setting of prior work, and we extended the MMLU-Pro evaluation to 500 examples with gemma-4-31B-it.

We thank the reviewers for their constructive suggestions, which we believe have strengthened the paper. We hope the rebuttal has addressed the concerns raised by the reviewers, and we are glad that all reviewers found the response helpful to reflect on the final score.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.