Collective Reasoning, Single-Writer Execution: Fusion-MoA for Long-Horizon Agents

arXiv:2609.26080 · cs.MA, cs.DC · Submitted 2026-08-03 · Read on arXiv

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

  1. 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.

  2. Implementing an authority-bounded collective runtime ensures that any model-originated final response or actionable intent is issued by ep, guaranteeing that zero Analyst actions and zero bypass effects occur during tool use.

  3. 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.

  4. 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

Related papers