Collective Reasoning, Single-Writer Execution: Fusion-MoA for Long-Horizon Agents
Listen
Radio episode about this paper
Transcript
Introduction to the show: ident: Computer Science. The day in computer science: software, systems and theory on arXiv.
Tom: We're looking at the paper: "Collective Reasoning, Single-Writer Execution".
Jane: Here's the gist of the paper. The model exposed to an application need not be a single checkpoint; it can be a governed fleet<ref:2609.26080#pg2> FusionMoA Pioneer R1 defines a versioned Profile over independently served Model Cells<ref:2609.26080#pg2> This runtime exposes independently served heterogeneous Cells as one OpenAI-compatible model<ref:2609.26080#pg2> The resulting service has one API and one writer, but many independently evolvable models<ref:2609.26080#pg2> Pruning redundant reasoning tokens Fusion-MoA Pioneer R1 defines a versioned Profile over independently served Model Cells<ref:2609.26080#pg2> The Profile establishes three contracts, including its identity contract which fixes eligible Cells, admission, evidence budget, finalizer, and validation<ref:2609.26080#pg2> Its authority contract admits typed, read-only evidence while reserving final text and tool intent for one Executor<ref:2609.26080#pg2> The evolution contract permits one qualified Cell to be promoted or rolled back without changing the public API<ref:2609.26080#pg2> This separation of identity from serving implementation is achieved through an operator-driven transition system<ref:2609.26080#pg2> How the training signal is built Communication is treated as a bounded, typed evidence path rather than free-form multi-agent conversation<ref:2609.26080#pg2> Collaboration is admitted by the deterministic predicate ggen(ht, µ) = 1
µon ∧ (µhard ∨ κt−1 = κt): <ref:2609.26080#pg2> When ggen = 1, the Gateway freezes one Evidence Snapshot St = Freezep(ht) and sends that immutable view to the readonly Analysts<ref:2609.26080#pg2> Each response must bind to the Snapshot, satisfy the typed Packet schema, cite valid evidence, and arrive on time<ref:2609.26080#pg2> The trace stores pre- and post-communication states, profile version, artifact hashes, outcomes, and verifier references<ref:2609.26080#pg2> Where the gains come from The capability study shows that the runnable Fusion-MoA Profile solves 8/10 problems versus 6/10 for the strongest individual Cell<ref:2609.26080#pg2> A preserved trace shows minority knowledge transferred to three initially incorrect or empty Cells<ref:2609.26080#pg2> The coding case demonstrates that every model-originated tool action remains attributable to the sole Executor, with zero Analyst actions and zero bypass effects<ref:2609.26080#pg2> Cell-Local Evolution allows for a successful promotion of one candidate while the public API remains unchanged<ref:2609.26080#pg2> Operational constraints and invariants The sole-writer invariant is c: write ∈ Ap(c) = 1, ∀c ≠ ep, ∀ρ: c →∗ Effect, ep ∈ ρ<ref:2609.26080#pg2> Every Analyst can read St and emit only a Packet into a non-executable channel<ref:2609.26080#pg2> The only Analyst egress is Ap packet−−−−→ Parser packet−−−−→ Selector evidence−−−−−→ Renderer evidence--> ep intent--> ResponseBoundary<ref:2609.26080#pg2> Proposition 1 states that for every reachable execution of the general or coding Profile, W(pcoding) = 1<ref:2609.26080#pg2> This ensures that any model-originated final response or actionable intent is issued by ep<ref:2609.26080#pg2> The transition types satisfy (σ, R)request−−→(σ′, R), (σ, R)operator−−−→(σ, R′), dH(R′, R) ≤ 1<ref:2609.26080#pg2> This bounds registry blast radius by mutating only one registry key atomically<ref:2609.26080#pg2> The paper concludes that a governed Fleet can operate as one governed service, giving collective intelligence an observable property of that fleet<ref:2609.
Paper summary: Tom: So, to wrap up this look at the "Collective Reasoning, Single-Writer Execution: Fusion-MoA for Long-Horizon Agents" paper, what's the big picture takeaway? It’s about moving away from single checkpoints toward a governed fleet of models <ref:2609.26080#pg1>.
Jane: I think the key concept here is that you can have many independently served model cells but they all operate under one versioned Profile <ref:2609.26080#pg1>. This Profile defines the rules for membership and what evidence is allowed in, while a single Executor keeps control over the final action <ref:2609.26080#pg1>.
Lu: It’s about creating this stable collective contract that lets you evolve individual components safely without messing up the public API <ref:2609.26080#pg1>. The authors show that even with this structure, you get better performance on complex tasks compared to a single strong model <ref:2609.26080#pg1>.
Meng: From a deployment perspective, the idea of separating the serving engine from the model boundary is important for scaling <ref:2609.26080#pg2>. It lets you optimize how things run locally on your infrastructure <ref:2609.26080#pg1>.
Lalam: And because of this strict enforcement, any model-originated final response or action is guaranteed to be issued by that sole Executor <ref:2609.26080#pg3>. It ensures accountability across the entire reasoning process <ref:2609.26080#pg3>.
Tom: So, the paper gives us a way to have collective intelligence that we can actually manage and observe as a single service <ref:2609.26080#pg1>. It’s about building systems where the fleet itself has an observable property <ref:2609.26080#pg1>.
Jane: It seems like this work is really pushing the idea that a fleet of models can function as one governed service, giving collective intelligence a way to be observable <ref:2609.26080#pg1>.
Conclusion: Tom: So, this paper is about taking a bunch of separate AI models and making them work together in one governed system called Fusion MoA for Long-Horizon Agents <ref:2609.26080#pg1>.
Jane: It’s about how to manage a whole fleet of different models so they act like one single, reliable service instead of just a collection of independent things <ref:2609.26080#pg1>.
Lu: The core idea is defining this versioned Profile that sets the rules for what every model cell can do and how it interacts with everything else <ref:2609.26080#pg2>.
Meng: So, instead of having fifty different models running around, you have one central control mechanism dictating how they communicate <ref:2609.26080#pg1>.
Lalam: And the big win is that this structure allows for model evolution—you can update one cell without changing the whole public interface <ref:2609.26080#pg4>.
Tom: It sounds like they’ve solved a problem where you have many models but you don't have clear control over the final output <ref:2609.26080#pg1>.
Jane: Exactly, and it points toward a way to make collective intelligence more trustworthy because there’s one single point of accountability for the final action <ref:2609.26080#pg3>.
Lu: The results show that this setup solves eight out of ten problems where you tried using just one strong individual model <ref:2609.26080#pg3>.
Meng: Eight out of ten is good, but what about the real world? Does this still run fast and cheap when you have dozens of these cells communicating constantly across a fleet?
Tom: That’s a fair question, Meng. The authors show that the coding case proves every single tool action comes from that one Executor <ref:2609.26080#pg3>. No Analyst actions, no bypass effects at all <ref:2609.26080#pg3>.
Jane: That means if you trust the system, you can look at the trace and know exactly who did what, which is a huge step for debugging these complex AI agents <ref:2609.26080#pg1>.
Lu: It’s about moving from just training one big model to building an entire ecosystem of models that collaborate under a strict set of contracts <ref:2609.26080#pg2>.
Tom: So, it’s not just about bigger models; it’s about better governance for the whole fleet <ref:2609.26080#pg1>.
Jane: Right. And this leads us to thinking about how we can actually deploy these governed fleets in real production environments next week <ref:2609.26080#pg4>.
Zongyou Yang, Yinghan Hou
Dyson School of Design Engineering · Department of Electrical and Electronic Engineering
cs.MA, cs.DC
Submitted: 2026-08-03
Updated: 2026-10-31
Comments: 9 pages, 2 figures, 9 tables
License: http://arxiv.org/licenses/nonexclusive-distrib/1.0/
Importance score: 92/100
The gist: The model exposed to an application need not be a single checkpoint; it can be a governed fleet<ref:2609.26080#pg2> FusionMoA Pioneer R1 defines a versioned Profile over independently served Model…
Key concepts
- Model Cells
- These are the independently served individual models that make up the larger system. Instead of one monolithic model, FusionMoA allows for many different models to be used together within a unified service.
- Profile
- The Profile acts as a governing structure defining three key contracts: identity (which eligible cells are allowed), admission (what evidence is accepted), and evolution (how models can be updated). It separates the system's identity from the serving implementation.
- Evidence Path
- Communication in this system is treated as a typed path of evidence, not free conversation. Collaboration requires a specific deterministic condition to freeze an immutable snapshot of evidence, ensuring all subsequent responses are bound to that verified state.
- Sole-Writer Invariant
- This constraint ensures that for any given entity, only one writer can modify it at a time. This strict rule guarantees that every model-originated final response or actionable intent is issued by a single, traceable executor.
Terminology
Summary
The model exposed to an application need not be a single checkpoint; it can be a governed fleet<ref:2609. p. 026080#pg2> FusionMoA Pioneer R1 defines a versioned Profile over independently served Model Cells<ref:2609. p. 026080#pg2> This runtime exposes independently served heterogeneous Cells as one OpenAI-compatible model<ref:2609. p. 026080#pg2> The resulting service has one API and one writer, but many independently evolvable models<ref:2609. p. 026080#pg2>
Pruning redundant reasoning tokens
Fusion-MoA Pioneer R1 defines a versioned Profile over independently served Model Cells<ref:2609.26080#pg2> The Profile establishes three contracts, including its identity contract which fixes eligible Cells, admission, evidence budget, finalizer, and validation<ref:2609. p. 026080#pg2> Its authority contract admits typed, read-only evidence while reserving final text and tool intent for one Executor<ref:2609. p. 026080#pg2> The evolution contract permits one qualified Cell to be promoted or rolled back without changing the public API<ref:2609. p. 026080#pg2> This separation of identity from serving implementation is achieved through an operator-driven transition system<ref:2609. p. 226080#pg2>
How the training signal is built
Communication is treated as a bounded, typed evidence path rather than free-form multi-agent conversation<ref:2609.26080#pg2> Collaboration is admitted by the deterministic predicate ggen(ht, µ) = 1[µon ∧ (µhard ∨ κt−1 = κt)]<ref:2609. p. 226080#pg2> When ggen = 1, the Gateway freezes one Evidence Snapshot St = Freezep(ht) and sends that immutable view to the readonly Analysts<ref:2609. p. 226080#pg2> Each response must bind to the Snapshot, satisfy the typed Packet schema, cite valid evidence, and arrive on time<ref:2609. p. 226080#pg2> The trace stores pre- and post-communication states, profile version, artifact hashes, outcomes, and verifier references<ref:2609. p. 226080#pg2>
Where the gains come from
The capability study shows that the runnable Fusion-MoA Profile solves 8/10 problems versus 6/10 for the strongest individual Cell<ref:2609.26080#pg2> A preserved trace shows minority knowledge transferred to three initially incorrect or empty Cells<ref:2609. p. 026080#pg2> The coding case demonstrates that every model-originated tool action remains attributable to the sole Executor, with zero Analyst actions and zero bypass effects<ref:2609. p. 026080#pg2> Cell-Local Evolution allows for a successful promotion of one candidate while the public API remains unchanged<ref:2609. p. 426080#pg2>
Operational constraints and invariants
The sole-writer invariant is c: write ∈ Ap(c) = 1, ∀c ≠ ep, ∀ρ: c →∗ Effect, ep ∈ ρ<ref:2609.26080#pg2> Every Analyst can read St and emit only a Packet into a non-executable channel<ref:2609. p. 226080#pg2> The only Analyst egress is Ap packet−−−−→ Parser packet−−−−→ Selector evidence−−−−−→ Renderer evidence--> ep intent--> ResponseBoundary<ref:2609. p. 726080#pg2> Proposition 1 states that for every reachable execution of the general or coding Profile, W(pcoding) = 1<ref:2609. p. 726080#pg2> This ensures that any model-originated final response or actionable intent is issued by ep<ref:2609. p. 726080#pg2> The transition types satisfy (σ, R)request−−→(σ′, R), (σ, R)operator−−−→(σ, R′), dH(R′, R) ≤ 1<ref:2609. p. 726080#pg2> This bounds registry blast radius by mutating only one registry key atomically<ref:2609. p. 726080#pg2> The paper concludes that a governed Fleet can operate as one governed service, giving collective intelligence an observable property of that fleet<ref:2609. p. 4
Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.
Improvements for AI systems
-
Governing heterogeneous model fleets means that an application need not be a single checkpoint; it can be a governed fleet, providing one API for many independently evolvable models while maintaining a single writer and authority boundary.
-
Implementing an authority-bounded collective runtime ensures that
any model-originated final response or actionable intent is issued by ep,
guaranteeing thatzero Analyst actions and zero bypass effects
occur during tool use. -
The system can perform minority knowledge transfer where
three initially wrong or empty Cells independently recover after receiving identity-masked, verification-oriented evidence,
allowing the collective to solve more problems than the strongest individual Cell alone. -
Members of a fleet can evolve without changing the public API because qualification and rollback are handled through an
operator-driven single-slot evolution
where "dH(Rt+1, Rt) <= 1."
Sources
- CAMEL: Communicative Agents for "Mind" Exploration of Large Language Model Society
- AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation
- Magentic-One: A Generalist Multi-Agent System for Solving Complex Tasks
- More Agents Is All You Need
- Mixture-of-Agents Enhances Large Language Model Capabilities
- MasRouter: Learning to Route LLMs for Multi-Agent Systems
- Can Small Agents Collaborate to Beat a Single Large Language Model?
- Rethinking Mixture-of-Agents: Is Mixing Different Large Language Models Beneficial?
- Can LLM Agents Really Debate? A Controlled Study of Multi-Agent Debate in Logical Reasoning
- AI safety via debate
- Benefits and Limitations of Communication in Multi-Agent Reasoning
- Hear Both Sides: Efficient Multi-Agent Debate via Diversity-Aware Message Retention
- Dynamic Trust-Aware Sparse Communication Topology for LLM-Based Multi-Agent Consensus
- Streaming Communication in Multi-Agent Reasoning
- Beyond Consensus: Trace-Level Synthesis in Mixture of Agents
- ReAct: Synergizing Reasoning and Acting in Language Models
- SWE-agent: Agent-Computer Interfaces Enable Automated Software Engineering
- AgentBench: Evaluating LLMs as Agents
- Terminal-Bench: Benchmarking Agents on Hard, Realistic Tasks in Command Line Interfaces
- Better Harnesses, Smaller Models: Building 90% Cheaper Agents via Automated Harness Adaptation
Related papers
- MultiAgentBench: Evaluating the Collaboration and Competition of LLM agents
- Iterative Negotiation and Oversight: A Case Study in Decentralized Air Traffic Management
- Towards using Large Language Models for Risk Negotiation and Consensus-building in One Health contexts
- A-MapReduce: Executing Wide Search via Agentic MapReduce
- AgentCue: Statistical Summaries for Guiding Decentralized Multi-Agent Self-Organization
- Events as Triggers for Behavioral Diversity in Multi-Agent Reinforcement Learning