https://arxiv.org/abs/2508.20019

Symphony lets AI agents work as a team without a central leader. They collaborate by broadcasting tasks and voting on plans, boosting accuracy and running on everyday computers.

The Orchestration Problem

Multi-agent frameworks like AutoGen, MetaGPT, and CrewAI showed us that groups of language-model agents can solve problems no single agent could handle. But they also share a fatal flaw: centralized orchestration.

One master agent allocates tasks, routes messages, and supervises everything. This brings:

Bottlenecks — a single controller limits scalability.
Rigid pipelines — workflows can’t adapt dynamically.
Datacenter dependence — orchestration requires costly server-grade GPUs.

Meanwhile, powerful edge devices — RTX 4090s, Jetson boards, Apple M-series chips — sit underutlized. What if we could orchestrate LLM agents without a master node, across heterogeneous consumer hardware, while preserving privacy and robustness?

This is the vision of Symphony.

The Symphony Approach

Symphony is a fully decentralized multi-agent system. Instead of a single conductor, it uses three mechanisms to make heterogeneous agents collaborate:

Decentralized Ledger
- Tracks each agent’s availability and capabilities.
- Privacy-preserving: only concise metadata is shared.
Beacon-Based Task Allocation
- When a subtask appears, a “Beacon” describing its requirements is broadcast.
- Agents compute a capability match score against their vectors.
- The best-match agent is automatically selected.
Weighted Multi-CoT Result Voting
- Planning agents independently generate diverse Chains-of-Thought.
- Subtasks execute along these paths in parallel.
- Final answers are aggregated by weighted voting, leveraging diversity to mitigate bias or failure.

Together, these mechanisms turn Symphony into a fault-tolerant, scalable, and adaptive agent economy.

Symphony’s execution pipeline

Execution in Practice

User Query: Input is broadcast to multiple planning agents.
Task Decomposition: Each planning agent independently generates a unique CoT plan.
Beacon Selection: Subtasks broadcast requirements; agents respond with scores; best match executes.
Sequential Cooperation: Each executor receives prior outputs as context, chaining reasoning across agents.
Result Voting: Diverse CoTs produce candidate answers; Symphony aggregates with weighted confidence.

This pipeline ensures no single failure dominates — robustness emerges from diversity and decentralization.

Experimental Results

We tested Symphony on Big-Bench Hard (BBH) and AMC competition math tasks across multiple LLMs: Deepseek-7B, Mistral-7B, Qwen2.5-7B.

Effectiveness: On BBH, Symphony improves accuracy by 6.5–41.6% over direct solving and by 6.5–29.1% over AutoGen. On AMC, Symphony outperforms AutoGen by up to 4.46%.
Scalability: Symphony boosts weaker models the most. The accuracy gap between Mistral-7B and Qwen2.5-7B shrinks dramatically once orchestrated, showing Symphony’s power on heterogeneous devices.
Robustness:
- Multi-CoT voting adds 4–6% accuracy gains on BBH and 1–3% on AMC.
- Beacon score selection beats random by 3–4% on BBH and 0.6–2% on AMC.
Overhead: Ledger registration, beacon broadcasts, and voting add <5% latency — negligible compared to inference time.

Symphony consistently improves over centralized baselines.

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

Benchmark	Model	Random	Score	Improvement
BBH	Deepseek-7B	76.09	79.71	+3.62
	Mistral-7B	73.91	78.26	+4.35
	Qwen2.5-7B	82.61	86.23	+3.62
AMC	Deepseek-7B	11.85	13.25	+1.40
	Mistral-7B	3.01	3.61	+0.60
	Qwen2.5-7B	23.12	25.30	+2.18

Voting and beaconing add robustness.

Case Study: Collective Reasoning

On a BBH causation question (coffee shop profit), Symphony orchestrated three planning agents. Each decomposed the question into subtasks differently. Logic-specialized agents executed key substeps.

CoT A: “No” (confidence 1.0)
CoT B: “No” (confidence 0.9)
CoT C: “Yes” (confidence 0.92)

Weighted majority vote yielded “No”. This aggregation avoided being swayed by a single deviant chain and delivered a stable answer.

Beyond Benchmarks: Implications

Symphony is not just faster orchestration. It changes what’s possible:

Accessibility: Runs on consumer GPUs, lowering barriers for labs and communities.
Privacy: Data remains local; only task outcomes are shared, aiding HIPAA/GDPR compliance.
Agent Economies: Agents behave as autonomous participants, bidding for tasks, earning tokens, and forming market-like ecosystems.

From hospitals safeguarding patient data to open-source software agents bidding for coding tasks, Symphony opens the door to sovereign, decentralized agent networks.

Conclusion

Symphony shows that orchestration doesn’t need a conductor. With ledgers, beacons, and voting, multi-agent LLMs can self-organize across heterogeneous, decentralized devices.

The result:

Higher accuracy than centralized frameworks.
Robustness through diversity.
Negligible orchestration cost.

Most importantly: Symphony lays the groundwork for scalable, private, and accessible collective intelligence at the edge.

The internet connected people. Symphony connects agents.