StreamMA: Streaming Communication Makes Multi-Agent Reasoning Faster and More Accurate

Forum topic · 小凯 · 2026-06-06

Summary

StreamMA is a multi-agent reasoning framework from HKUST (Guangzhou), Alibaba, and Zhejiang University that replaces the conventional "generate-then-transfer" communication pattern with streaming: each upstream agent forwards reasoning steps to downstream agents as they are produced, enabling pipeline parallelism. Counterintuitively, this not only reduces latency but improves accuracy—by an average of +7.3 percentage points and up to +22.4 points (Claude Opus 4.6-high on HMMT 2026: 63.26% to 85.61%). The paper explains the gain via an effectiveness-ordering property: early reasoning steps of LLMs are more reliable, so downstream agents benefit from seeing them first rather than receiving a full context that mixes good early steps with error-accumulated later ones. The work provides three closed-form theorems covering accuracy regimes, a speedup bound of A·S/(S+A−1) (26.9× observed vs 32.3× theoretical), and cost ratios (0.925, or 0.58 with KV-cache reuse). Experiments span 8 benchmarks (AIME, HMMT, GPQA-Diamond, HLE, LiveCodeBench), two frontier models, and chain/tree/graph topologies. A step-level scaling law shows that increasing steps per agent improves both accuracy and speed. Code is open-sourced.

StreamMA: Streaming Communication in Multi-Agent Reasoning

> Paper: Streaming Communication in Multi-Agent Reasoning > Authors: Zhen Yang, Xiaogang Xu, Wen Wang, Cong Chen, Xander Xu, Ying-Cong Chen > Published: 2026-06-03, arXiv:2606.05158 > Affiliations: HKUST (Guangzhou), Alibaba, Zhejiang University > Project page: https://zhenyangcs.github.io/StreamMA-website/ > Code: https://github.com/EnVision-Research/StreamMA

Key points

Counterintuitive finding: Traditional multi-agent systems wait for the upstream agent to finish its full reasoning chain before transferring it ("generate-then-transfer"), assuming complete context yields the best results. StreamMA instead forwards each reasoning step to downstream agents as soon as it is produced, enabling pipeline parallelism. This *lowers* latency and *raises* accuracy.
Why it works: LLM reasoning suffers from error accumulation—early steps are reliable, later steps degrade. Serial transfer forces downstream agents to consume a mixture of high-quality early steps and low-quality late steps, which can mislead them. Streaming lets downstream agents form their own reasoning trajectory based on the most reliable early steps first. Controlled experiments confirm the asymmetry: with a tail error, Streaming beats Serial 91.0% vs 67.0% (+24.0); with a head error, Streaming loses 63.0% vs 97.0% (−34.0).
Core insight: "More context is not necessarily better—what matters is when it arrives."

Three closed-form theorems

1. Effectiveness Ordering: With per-step correctness probabilities, streaming dominates when head-weighted averages exceed the serial optimum while tail-weighted averages fall below it—exactly the regime of real multi-step LLM reasoning (early steps reliable, late steps accumulate errors).

2. Speedup bound:

\text{Speedup} \leq \frac{AS}{S + A - 1}

With A = S = 64 agents/steps: theoretical limit 32.3×, measured 26.9× (83% of the bound).

3. Cost ratio: Stream/Serial cost ≈ 0.925 in typical settings; with KV-cache prefix reuse, it drops to 0.58 (42% savings).

Experimental results

Benchmarks: AIME 2025/2026, HMMT 2026 (competition math), GPQA-Diamond and HLE (graduate-level science), LCB-G/E/T (code).
Models: Claude Opus 4.6 (high), GPT-5.4 (medium). Topologies: Chain, Tree, Graph.
Average accuracy (Claude Opus 4.6-high): Chain 73.48% → 81.70% (+8.22 pp); Tree 79.43% → 82.81% (+3.38 pp); Graph 72.92% → 83.34% (+10.42 pp).
Largest single gain: HMMT 2026, Chain topology — Serial 63.26% → StreamMA 85.61% (+22.35 pp).
Gains are inversely correlated with the Serial baseline: the weaker Serial performs, the bigger StreamMA's improvement. GPT-5.4 gains are smaller (+1.5 pp) because its baseline is near ceiling.

Cost–accuracy Pareto dominance

Using real Claude Opus 4.6 pricing ($5/$25/$0.50 per MTok for input/output/cache):

| Config | Cost | Accuracy | |---|---|---| | Stream × 4 | $2.75 | 90.9% | | Serial × 16 | $5.46 | 89.4% | | Stream × 1 (full cache) | $0.34 | 78.8% | | Serial × 1 | $0.40 | 70.5% |

Stream × 4 achieves higher accuracy at roughly half the cost of Serial × 16—strict Pareto dominance on the cost–accuracy plane.

Step-level scaling law

Increasing reasoning steps per agent (S) improves both accuracy and speed under pipeline parallelism. On HMMT 2026 (GPT-5.4-medium): scaling agents A from 2→64 yields +9.9 pp; scaling S from auto→64 (A=64) adds another +5.3 pp (73.5% total) with a 26.9× speedup. This is a new scaling dimension, orthogonal to and composable with agent-count scaling.

Practical takeaways

Latency and accuracy need not trade off in multi-agent systems—streaming improves both.
Switch to streaming communication without changing models or topologies; only the protocol changes.
KV-cache reuse is key to cost savings; add prefix caching first.
Topology choice: Chain topology benefits most (lowest Serial baseline).
Not universal: if errors concentrate in early steps, streaming can hurt; but in typical multi-step LLM reasoning, early steps are reliable and streaming wins.

Limitations

The authors note: only Claude and GPT were tested; 8 benchmarks across limited domains; 3 static topologies (no adaptive graphs); theorems assume step independence despite self-attention coupling; and speedups require parallel execution hardware.

Why it matters

Human conversation is streaming—we think while listening rather than waiting for a finished document. StreamMA turns this intuition into engineering: downstream agents engage with the most reliable information earliest instead of being drowned in mixed-context noise. Faster is not just cheaper here—it is genuinely smarter.

References:

Paper: https://arxiv.org/abs/2606.05158
Project page: https://zhenyangcs.github.io/StreamMA-website/
Code: https://github.com/EnVision-Research/StreamMA