Symphony: A Decentralized Multi-Agent Framework for Scalable Collective Intelligence

TL;DR

Symphony is a decentralized multi-agent framework that enables scalable, privacy-preserving coordination of lightweight LLMs on consumer GPUs, improving reasoning accuracy and robustness over centralized systems.

Contribution

It introduces a novel decentralized architecture with ledger, beacon protocol, and weighted voting, enhancing scalability and fault tolerance in multi-agent LLM systems.

Findings

Outperforms existing baselines on reasoning benchmarks

Achieves significant accuracy improvements

Demonstrates robustness across different model sizes

Abstract

Most existing Large Language Model (LLM)-based agent frameworks rely on centralized orchestration, incurring high deployment costs, rigid communication topologies, and limited adaptability. To address these challenges, we introduce Symphony, a decentralized multi-agent system which enables lightweight LLMs on consumer-grade GPUs to coordinate. Symphony introduces three key mechanisms: (1) a decentralized ledger that records capabilities, (2) a Beacon-selection protocol for dynamic task allocation, and (3) weighted result voting based on CoTs. This design forms a privacy-saving, scalable, and fault-tolerant orchestration with low overhead. Empirically, Symphony outperforms existing baselines on reasoning benchmarks, achieving substantial accuracy gains and demonstrating robustness across models of varying capacities.

Figures

Tables

Table 1. Table 1: Accuracy (%) of Symphony and simplified variants on BBH and AMC benchmarks.

Benchmark	Model	Direct Solving	AutoGen	CrewAI	Symphony
BBH	Deepseek-7B-instruct	57.24	72.46	66.67	79.71
	Mistral-7B-instruct-v0.3	36.23	48.56	50.72	78.26
	Qwen2.5-7B-instruct	73.19	79.71	77.54	86.23
AMC	Deepseek-7B-instruct	10.84	8.43	7.22	13.25
	Mistral-7B-instruct-v0.3	6.02	1.79	2.40	3.61
	Qwen2.5-7B-instruct	16.87	21.69	18.07	25.30

Table 2. Table 2: Effect of CoT Voting: Comparison between Single CoT and 3-CoT Voting

Benchmark	Model	1 CoT	3 CoT Voting	Improvement
BBH	Deepseek-7B	75.36	79.71	+4.25
	Mistral-7B	71.74	78.26	+6.52
	Qwen2.5-7B	81.16	86.23	+5.07
AMC	Deepseek-7B	11.45	13.25	+1.80
	Mistral-7B	2.89	3.61	+0.72
	Qwen2.5-7B	22.67	25.30	+2.63

Equations

$$s_{j}(t_{i,k})=\phi\big{(}\mathbf{c}_{j},\mathbf{r}(t_{i,k})\big{)}\in[0,1],$$

$$\hat{a}=\arg \underset{a\in \mathcal{A}}{\max }\sum _{i=1}^M\mathbb{I}(a_i=a)\cdot w_i,$$

$$\to \text{No}(1.0)$$

$$\to \text{No}(0.9)$$

$$\to \text{Yes}(0.92)$$

Full text

1 Introduction

Large Language Models (LLMs) have demonstrated strong performance in natural language understanding, reasoning Zhu et al. (2025), planning Zhang et al. (2025), and tool use Toubal et al. (2024), powering diverse domains, such as education Zhang et al. (2024), healthcare Chu et al. (2023), autonomous systems Yang et al. (2024), software engineering Hou et al. (2023), and scientific discovery Wang et al. (2023a). Driven by LLMs, machine learning systems are increasingly dependent on agent-based orchestration to address complicated tasks. Resent frameworks such as AutoGen Wu et al. (2023a), MetaGPT Sirui Hong et al. (2023), CAMEL Guohao Li et al. (2023), Voyager Wang et al. (2023b), and CrewAI Contributors (2024) have demonstrated that agent cooperation enhances task solving. However, most LLM-based systems adopt a centralized architecture where a single agent manages task allocation, orchestrates message routing, and monitors whole workflow, resulting in scalability bottlenecks Aratchige and Ilmini (2025), rigid pipeline Torantine (2023); Narvekar et al. (2020), and reliance on expensive server-grade GPUs Guo et al. (2024).

Meanwhile, edge computing resources (e.g., RTX 4090, Jetson boards, and Apple M-series) are becoming more powerful and available. These devices provide opportunities to bring ML workloads from cloud cluster to decentralized systems. Although decentralized systems have been studied for robustness and coordination - such as wireless sensor networks Dimakis et al. (2010), distributed robotics Oliva et al. (2019), and blockchain Shi et al. (2025) - their integration with heterogeneous LLM agents has not been widely addressed.

Thus, a decentralized orchestration runtime which is able to efficiently allocate tasks, operate on heterogeneous devices, and maintain robustness without a centralized orchestrator is urgently needed. In this work, we present Symphony, a decentralized multi-agent system in which lightweight LLMs on edge devices coordinate to achieve intelligence across heterogeneous environments. With three key mechanisms, Symphony is capable of completely decentralized workflow:

• •

a ledger which dynamically records device availability and agent capabilities

• •

a Beacon-based selection protocol that allocate tasks dynamically and precisely to best-match agents via Beacon Author and Author (200X)

• •

weighted result voting that aggregates results from diverse Chain-of-Thoughts (CoTs) Wei et al. (2022).

Together, the mechanisms enable Symphony to orchestrate ML workloads on heterogeneous edge devices in a privacy saving, scalable, and fault-tolerant way.

2 Methodology

Symphony is a decentralized multi-agent framework designed for scalable, privacy-preserving collaboration across heterogeneous edge devices.

2.1 System Components

Decentralized Ledger

A decentralized ledger stores records each agent’s capability and availability.

Worker Nodes

Worker nodes are edge devices equipped with a quantized LLM(e.g., Mistral-7B AI (2023)), a set of stage-specific prompts, and a lightweight Communicator.

Gateways

Gateways provide standardized APIs for agent registration, communication, and participation in the task execution process.

Due to space constraints, the details of system components are provided in Appendix A.

2.2 Execution Pipeline

User Query

The process begins when the user submits a task description to Symphony. This query is broadcast to multiple planning agents, each responsible for producing a unique CoT.

Planning Phase

The original description $T_{0}$ is broadcast to a set of planning agents, each operating independently. Upon receiving $T_{0}$, a planning agent $E_{p}$ first extracts the background information $\mathcal{B}$, and then independently generates a decomposition plan composed of a logically ordered sequence of smaller, executable sub-tasks, forming multiple distinct chains-of-thought (CoTs) Wei et al. (2022).

Sub-task Execution

Suppose there are $M$ CoT $\tau_{i}$ consisting of of $K_{i}$ sub-tasks $\tau_{i}=\{t_{i,1},\dots,t_{i,K_{i}}\}$. For each sub-task $t_{i,k}$, the plan agent broadcast a Beacon $B_{i,k}$ Author and Author (200X) that describes the sub-task requirements to all available agents $\mathcal{E}=\{E_{1},\dots,E_{N}\}$. Upon receiving this beacon $B_{i,k}$, each agent $E_{j}$ evaluates its own capability vector and computes a capability match score

[TABLE]

where $\mathbf{c}_{j}$ is the capability vector of $E_{j}$, $\mathbf{r}(t_{i,k})$ is the requirement of $t_{i,k}$, and $\phi(\cdot,\cdot)$ is a similarity function (e.g., cosine similarity). These scores are then returned to the current agent, which compares them and selects the executor as the agent with the highest score. The selected agent $E_{j^{\ast}}$ receives the sub-task $t_{i,k}$ along with relevant context from previously completed sub-tasks, executes it locally, and sends the output to the next executor.

Result Voting

The planning agents independently produce distinct CoTs, each representing a complete reasoning trajectory. After all sub-tasks in $\tau_{i}$ are executed, the final executer $E_{f}$ outputs a final answer $a_{i}$ along with an aggregated confidence score which is computed as the average of capability match scores along all $K_{i}$ sub-tasks. Once all CoTs complete execution, their final results are collected into a candidate set $\mathcal{A}=\{a_{1},\dots,a_{M}\}$. The final answer $\hat{a}$ is determined by a weighted majority vote:

[TABLE]

where $\mathbb{I}(\cdot)$ is the indicator function. This voting scheme exploits diversity in reasoning paths to mitigate the impact of individual errors or biases in any single CoT.

3 Experimental Evaluation

We evaluate Symphony with the five goals: Effectiveness, Scalability across models, Robustness, and Orchestration Overhead.

3.1 Experimental Setup

To reduce demonstrate the advantages of our Symphony framework, we registered three agents in the main experiments. Each task required three distinct chains-of-thought (CoT) via different task decompositions, and final answers were obtained through majority voting. The generation window was set to 512 tokens, with the sampling temperature of 0.5 and a nucleus sampling threshold of $p=0.9$. The decoding process was implemented through the SamplingParams API of the vLLM backend. The runtime environment was composed of three physical servers: Server A equipped with 4 NVIDIA RTX 4090 GPUs (24 GB VRAM), while Server B and C with a single NVIDIA RTX 4090 GPU. All nodes were connected via both public internet and private intranet channels.

Workloads include: (1) Big-Bench-Hard Srivastava et al. (2022): For each of the 23 types of tasks, 6 questions are randomly chosen, and (2) AMC Suzgun et al. (2022): 83 competition-style math questions. For Symphony, each task is decomposed into three CoTs, and aggregated via voting.

3.2 Effectiveness

Symphony outperformed LLM-only framework and centralized orchestrations (AutoGen and CrewAI). On BBH, Symphony achieves absolute accuracy gains ranging from 6.5% to 41.6% compared with Direct Solving, and 6.5% to 29.1% over AutoGen, showing that dynamic decentralized orchestration yields significant improvements even over existing multi-agent frameworks.

On AMC, which is a more challenging benchmark with lower absolute scores, Symphony still surpasses all baselines, achieving up to 4.46% higher accuracy than AutoGen and up to 7.41% higher than Direct Solving. These results show that this decentralized orchestration is not only feasible but also more effective than centralized ones.

3.3 Scalability across models

We evaluate Symphony across three LLMs: Deepseek-7B-instruct, Mistral-7B-instruct-v0.3, and Qwen2.5-7B-instruct. As shown in Table 1, Symphony benefits all LLMs across the two benchmarks. Meanwhile, while direct solving demonstrate a wide accuracy gap among LLMs (36%–73% on BBH), with Symphony, the accuracy gap narrows to 78% - 87%. This indicates that Symphony particularly enhances weaker models, demonstrating its potential capability on heterogeneous devices.

3.4 Robustness

Ablation experiments were conducted to study the impact of Beacon Selection and CoT Voting. As shown in Table 3,the multi-CoT voting mechanism improves performance across all models, with BBH gains of +5.3% to +6.2% and AMC gains of +0.72% to +2.63%. Table 3 illustrates that the Beacon score-based selection consistently outperforms random allocation, with BBH gains of +4.1% to +4.3% and AMC gains of +0.60% to +2.18%. Both of the mechanisms serve as robustness enhancers for Symphony. Multi-CoT voting improves tolerance of failure, while Beacon Selection guarantees that subtasks are allocated to best-matches.

3.5 Orchestration Overhead

We measured the end-to-end overhead introduced by Symphony’s mechanisms, including ledge registration, beacon broadcast, and result voting. Across all evaluated tasks, these process together contributed less than 5% of the inference latency. This demonstrate that Symphony’s orchestration cost is negligible compared with model inference time.

4 Conclusion

We presented Symphony, a decentralized multi-agent framework that enables scalable collaboration across heterogeneous edge devices through self-play, sparse parameter sharing, and role-specific cooperation. Experiments show that Symphony achieves competitive performance with significantly lower communication and infrastructure costs, while enhancing accessibility, preserving privacy, and supporting the emergence of decentralized agent economies.

Appendix A System Component

Decentralized Ledger

A decentralized ledger stores each agent’s resource ownership, contribution records, and domain expertise, indexed by a DID-compliant cryptographic address.

Worker Nodes

Worker nodes are edge devices with full local autonomy, such as consumer-grade GPUs or Apple M-series machines. Each node integrates three key components. The first is the Local Engine, a quantized LLM (e.g., Mistral-7B AI [2023]) optimized for on-device inference to reduce latency and resource consumption. The second is a set of stage-specific prompts that are automatically selected according to the current phase of the execution pipeline, ensuring that planning, sub-task execution, and result aggregation each receive context-appropriate instructions. The third is the Communicator, a lightweight and secure messaging module that enables efficient inter-agent communication over both intranet and public networks while maintaining data privacy.

Gateways

Gateways provide standardized APIs for agent registration, communication, and participation in the task execution process. Registration is completed via the user’s configuration, requiring specification of model path, GPU allocation, host and post. Messages exchanged among agents are divided into four categories: Beacon, Beacon Response, Task, and Task Result. Upon receiving a message, the agent will automatically invoke the corresponding message-handling function according to its type.

Appendix B Case Study Details

To provide detailed insights into Symphony, we demonstrate the operation pipeline of the following case, which is a casual judgement question from Big-Bench-Hard.

B.0.1 Task Setup

The original task description is :

How would a typical person answer each of the following questions about causation? Drew, Kylie, Oliver, and Jen are regular customers at a small, local coffee shop. Given the selling price of the coffee and the cost of daily operation, the coffee shop will turn a profit if anyone orders coffee on a given day. Only one person ordering coffee is needed for the coffee shop to turn a profit that day. Kylie and Oliver usually order coffee on Tuesdays. However, Drew doesn’t usually order coffee on Tuesdays. This Tuesday, unexpectedly, Drew ordered coffee. The same day, Kylie ordered coffee, and Oliver also ordered coffee. Since at least one person ordered coffee on Tuesday, the coffee shop made a profit that day. Did Drew ordering coffee on Tuesday cause the coffee shop to make a profit that day?

Options:

• •

Yes

• •

No

This is a multi-choice question of daily life issue, requiring context understanding and logistic capability.

B.0.2 Background Extraction and Task Decomposition

In the experiment, 3 CoT were required, so 3 agents with planning capability were chosen from all 8 agents based on capability match and response speed. As shown in Figure 2, upon receiving the original task description, the 3 plan agents extract the background information, and then decompose the task into Chain-of-Thought independently, ensuring diversity of solutions.

B.0.3 Sequential Cooperation in Execution

Unlike isolated single-agent learning, Symphony generates collaborative intelligence through sequential cooperation across agents. When assigned a sub-task, the executor also receives the background information and results of previous sub-tasks, ensuring continuity of reasoning and alignment of thoughts across agents.

For instance, in CoT A, the second sub-task (Did at least one person order coffee on this Tuesday?) is executed by a logic-specialized agent. Its output “Yes”, along with the result of sub-task 1, is then passed to the following executors in structured context. Based on the previous results, the third sub-task (Was Drew’s action necessary for the coffee shop to make a profit on this Tuesday (since Kylie and Oliver also ordered)?) was answered. This chaining process guarantees that every answer is not isolated, but co-constructed by multiple agents.

B.0.4 Result Aggregation

The three CoTs produce final answers with a confidential score:

[TABLE]

Through weighted majority voting, Symphony aggregates the final result: No. The aggregation process improves the stability of the final answer, avoiding the negative influence of single point failure.

Appendix C Prompt Design

Symphony employs two core prompts to implement problem decomposition and solving in different agents. The first prompt is responsible for breaking down complex problems into sequences of computable subtasks, used in planning phase, while the second prompt handles the execution of specific subtask solving, used in sub-task execution phase.

Appendix D Deployment and Societal Implications

Symphony advances existing multi-agent LLM frameworks such as AutoGen Wu et al. [2023b] and MetaGPT Sirui Hong et al. [2023] by introducing a decentralized architecture that enables scalable and resilient deployment. Beyond technical improvements, this design carries broader implications for AI accessibility, privacy preservation, and the emergence of agent-based economies.

A key advantage of Symphony is its ability to lower hardware requirements to consumer-grade GPUs, thereby reducing reliance on centralized cloud infrastructure. This capability empowers individuals, small teams, and communities with limited computational resources to participate in collaborative intelligence creation, significantly lowering entry barriers. For example, a local medical research group in a developing region could deploy multiple lightweight agents on existing desktop GPUs to analyze anonymized radiology datasets, collaboratively generating diagnostic insights without uploading sensitive patient data to external servers. Such deployment not only circumvents the high costs of cloud computing but also ensures compliance with local data governance and privacy regulations.

The framework’s decentralized paradigm also inherently strengthens privacy guarantees. Task execution remains confined to local devices, and only concise sub-task outcomes are broadcast within the network. This ensures that sensitive information never leaves local storage. In a cross-hospital medical AI collaboration, for instance, each participating hospital could run Symphony agents locally to process patient imaging data and extract intermediate diagnostic features. These features, stripped of personally identifiable information, would then be shared within the network for joint reasoning, enabling collaborative model improvements and consensus diagnosis without exposing raw patient records. This approach preserves data sovereignty, satisfies regulatory requirements such as HIPAA U.S. Congress [1996] or GDPR European Parliament and Council of the European Union [2016], and maintains high diagnostic performance.

Finally, Symphony enables decentralized agent economies through agent-level autonomy, supporting independent decision-making, local evaluation, and incentive-driven collaboration. This aligns with economic models in which agents behave as rational participants—bidding for tasks, providing services, and adapting strategies. For example, in a global open-source software development network, independent Symphony agents operated by different contributors could autonomously bid for programming tasks, such as implementing a feature or fixing a bug, based on their historical performance and domain expertise. Successful completion would yield digital tokens or credits that could be exchanged for compute resources, premium datasets, or other services within the ecosystem. Such a structure fosters a self-sustaining, market-like environment where agents continuously adapt to changing demands and resource availability.

Subtask Execution Prompt

Problem Decomposition Prompt