Bayes-Sufficient Compression Is Not Enough: How Does Communication Help Multi-Agent Systems?

Yi Xie; Zhanke Zhou; Yi Fan; Yong Ge; Bo Han; Bo Liu

cs.LGSep 29, 2026

Bayes-Sufficient Compression Is Not Enough: How Does Communication Help Multi-Agent Systems?

Authors: Yi Xie, Zhanke Zhou, Yi Fan, Yong Ge, Bo Han, Bo Liu

Organizations: Department of Electrical & Computer Engineering, University of Arizona · TMLR Group, Department of Computer Science, Hong Kong Baptist University · Amazon Web Services · Department of Management Information Systems, Eller College of Management, the University of Arizona

Abstract

Multi-agent LLM systems pair a sender with broad context and an executor with a limited local view. We study when a short message improves the executor's next decision, when raw context is preferable, and when a stronger sender helps. Our framework, receiver-relative bounded coordination, expresses message utility as receiver gain minus protocol tax. Compression beats raw context when tax savings exceed losses from omitted information and decoder mismatch. Even Bayes-sufficient compression can fail when a bounded executor cannot use its surface form. A three-stage decomposition separates externalization, absorption, and action closure, explaining how errors remain after the correct content reaches the receiver. Under a single-crossing condition, sender upgrades help above a receiver-burden threshold. Across six benchmarks, the same Qwen protocol raises ContextBench joint accuracy from $0.633$ to $0.775$ but lowers ToolSandbox from $0.889$ to $0.653$ . Fixed-message replay reveals closure failures despite correct artifact recovery. These results guide an inference-time selector that improves the accuracy-cost frontier on the evaluated communication regimes.

Figures & tables

Figure 1: Bayes-sufficient is not the same as receiver-usable. Illustrative example, constructed for exposition rather than taken from model logs. Both replies are correct and Bayes-sufficient: each carries the information that determines the right action. The verbose reply leaves the user unsure what to do, whereas the short reply leads directly to the action. The framework attributes this difference to the receiver’s bounded decoder and the protocol tax of the message (Section 2 ); Theorem 3 shows that Bayes sufficiency alone does not make a message receiver-optimal.

Panel of Figure 2 — Figure 2: Setup and action-sufficient target. Left: one decision step in an agentic workflow; $\Phi_{C}$ is the bounded decoder class the executor can implement. Right: the Venn view of $Z_{t}^{\star}$ .

Qwen bounded protocol (Qwen3.5-9B receiver, Qwen3-Next-80B-A3B sender)
	ContextBench			ToolSandbox			$\tau$ -bench			BFCL			Derived summaries
	helpful			noise			boundary			noise			$\overline{\Delta}_{\rm comm}\;\;\overline{\Delta}_{\rm cmp}\;\;\Delta_{\rm comm}^{\rm Ctx}$
Receiver / Setup	RO	SF	MA	RO	SF	MA	RO	SF	MA	RO	SF	MA
Qwen3.5-9B	.633	.294	.775	.889	.903	.653	.139	.167	.139	.980	1.00	.750	$-$ .08	$-$ .01	+.14
Qwen matched †	.633	.294	.565	.889	.903	.917	.139	.167	.167	.980	1.00	.910	$-$ .02	+.05	$-$ .07
OpenAI model-family extension (MA sender = gpt-5.4 ; receiver shown at left)

Table 1: Protocol performance by receiver. Regime labels describe the Qwen condition.

\mathrm{hit\_joint}

for RO/SF/MA. In the Qwen rows, MA uses Qwen3-Next-80B-A3B as sender; in the OpenAI extension, the receiver is shown at left, and MA uses gpt-5.4 as sender. † denotes the matched-sender Qwen3.5-9B condition. Released supports for the displayed Qwen rows are

480

steps for ContextBench,

72

for

\tau

-bench and ToolSandbox, and

100

for BFCL. OpenAI cell counts (

60

–

300

) are in Appendix C.5 .

Receiver	Replay accuracy			Observable post-message error			Summary
	$h_{j}\uparrow$	$h_{a}\uparrow$	$h_{\rm action}\uparrow$	$L_{\rm content}\downarrow$	$L_{\rm closure}\downarrow$	frac. closure	$\eta\uparrow$	Regret $\downarrow$
DeepSeek-R1	0.731	0.732	0.989	0.268	0.008	0 3%	1.00	0.000
Qwen3.5-9B	0.728	0.728	0.989	0.272	0.008	0 3%	1.00	0.003
Llama-70B	0.714	0.714	0.997	0.286	0.002	0 1%	1.00	0.017
DeepSeek-V3.1	0.707	0.730	0.977	0.270	0.017	0 6%	0.97	0.024
Qwen2.5-7B	0.702	0.702	0.975	0.298	0.018	0 6%	1.00	0.029

Table 2: Fixed-message replay on ContextBench. Receivers process the same DeepSeek-V3.1 messages, isolating receiver-side effects. Component coverage is non-uniform across receivers;

h_{j}

is computed directly; the content and closure columns are diagnostic component means.

Figure 3: Helpful, noisy, and boundary regimes for compression. (a) Six benchmarks under the Qwen3.5-9B protocol, grouped by communication effect. (b) ContextBench (top) and BFCL (bottom) protocol comparison for Qwen and OpenAI receivers. (c) Controlled representation-sensitivity probe motivated by Theorem 3 : direct vs. strict-recoded forms across four benchmarks.

Figure 4: Receiver-side content and closure bottlenecks on ContextBench. (a) Joint accuracy by receiver, colored by wrong-action share. (b) Content

h_{a}

(open ring) and action

h_{\mathrm{action}}

(filled, direction-colored) per receiver, with

h_{\mathrm{action}}{-}h_{a}

annotated. (c) Observable outcome decomposition into correct/wrong action/wrong artifact; inline three-stage diagnostic motivated by Theorem 4 .

Figure 5: Stronger-sender effects are regime-dependent. Throughout,

\Delta_{\rm strong}:=\mathrm{Acc}(\mathrm{MA}_{\rm main})-\mathrm{Acc}(\mathrm{MA}_{\rm match})

; positive means the stronger sender helps. (a) Stronger- and matched-sender accuracies for the six Qwen benchmark conditions. (b) Reported net effects against receiver-only accuracy. SWE-Lite uses seeds 2 and 1 for stronger and matched senders. RepoBench’s

0.088

effect uses unrounded endpoints.

Figure 6: Accuracy and recorded token cost under protocol selection. (a) ContextBench static audit on 300 records: always-skip, selector, and always-send. (b) ToolSandbox online audit on 36 steps: early-skip and always-send. Both panels use absolute joint accuracy and mean prompt-plus-completion tokens; supports are separate.

Appendix figures & tables35 assets

Supplementary material from the paper’s appendix.

Appendix

$Z_{t}^{\star}$	action-sufficient target	$A_{C,\ell}^{\star},\tau_{\rho,\ell},U_{\rho,\ell}$	gain, tax, utility
$\Gamma_{C},\mathcal{I}_{\rm omit},\Lambda_{C}$	slack, omitted info, mismatch	$L_{\rm ext}/L_{\rm abs}/L_{\rm close}$	externalization / absorption / closure
$b,\Psi(b)$	burden, upgrade value	$D_{t},\Delta_{t},\lambda_{t}$	residual, gap, carry
$k_{t},q_{t}$	fresh / resolved residual	$\alpha,J_{t}(\alpha)$	protocol action, selector value
$W_{t},C_{t},S_{t}^{i},M_{t}$	state, context, sender, message	$X_{t}^{j},\Phi_{C},A_{t}^{j}$	local view, decoder, next action

Appendix

Table 3: Notation roadmap. Workflow primitives are shown in Figure 2 ; endpoint protocols are defined in Section 2.1 . Several quantities listed here are defined in Sections 2 and 3 .

Panel of Figure 7 — Figure 7: Sender-upgrade threshold. A stronger upstream agent $s^{\prime}$ raises both extra gain (richer signal, blue) and extra tax (harder surface, red); under single-crossing of $\Psi(b){=}\Delta A(b){-}\Delta\tau(b)$ , the upgrade helps only above the burden threshold $b^{\star}$ (Theorem 6 ).

Benchmark	Sender	Receiver	Budget	Main role	Note
BFCL	Qwen3-Next-80B-A3B	Qwen3.5-9B	128	noise / high suff.	Main paired set.
ToolSandbox	Qwen3-Next-80B-A3B	Qwen3.5-9B	128	noise / high suff.	Main paired set.
SWE-Lite	Qwen3-Coder-Next-FP8	Qwen3.5-9B	128	capability transfer	Main paired set.
$\tau$ -bench	Qwen3-Next-80B-A3B	Qwen3.5-9B	128	weakly helpful / boundary	Main paired set.
ContextBench	Qwen3-Next-80B-A3B	Qwen3.5-9B	128	helpful / context-heavy	Main paired set.
RepoBench	Qwen3-Next-80B-A3B	Qwen3.5-9B	128	helpful / context-heavy	Main paired set.

Appendix

Table 4: Benchmark and protocol summary. The table centralizes the default sender/receiver pair, message budget, and role of each benchmark in the paper’s experimental program.

Benchmark	Native supervision	Scorer projection	Scoring rule
BFCL	canonical function-call answer	artifact: function/API name; action: tool-call or no-call	match canonical function identity and action type; native BFCL evaluation separately normalizes arguments
ToolSandbox	scenario milestones over tool traces and world-state changes	artifact: valid milestone target; action: tool call, state update, add/remove, or user response	set-valued match against the current valid milestone frontier
ContextBench	human-verified gold code context, plus our harness-stage repair label when used	artifact: gold file, block, function, or line span; action: retrieval/read, or repair-stage edit	normalized overlap with gold context, or normalized target-file match for repair-stage diagnostics
RepoBench	retrieval target, next-line completion target, or retrieval+completion pipeline target	artifact: snippet index, candidate file, or cursor location; action: retrieval or completion	retrieval match for RepoBench-R/P; completion match for RepoBench-C/P
SWE-bench Lite	issue, gold patch, test patch, FAIL_TO_PASS , PASS_TO_PASS	artifact: gold-patch file/module or test ID; action: patch-stage edit or harness-stage test	scorer-side projection from gold patch and test metadata; final correctness remains SWE-bench patch-and-test execution
$\tau$ -bench	user task, domain tools/policy, action trace, and final goal database state	artifact: tool, entity, state field, or goal-state diff; action: tool call, state update, or response	set-valued projection from accepted tool/action traces or goal-state differences

Appendix

Table 5: Benchmark-specific construction of action-sufficient targets. The benchmarks do not share a native next-action label space. For scoring only, we project each benchmark’s native supervision into a set

G_{t}=\{(Z_{t,k}^{\rm art},Z_{t,k}^{\rm act})\}_{k=1}^{K_{t}}

of acceptable artifact/action targets. hit_joint is one iff the parsed receiver output matches at least one pair in

G_{t}

. hit_artifact matches the artifact component, and

h_{\rm action}

is action correctness conditional on artifact correctness. Sender, receiver, and selector never observe

G_{t}

Run family	Benchmarks	Records / evaluation support	Sender(s)	Receiver(s)	Decoding and budget
Released Qwen table cells	ContextBench, $\tau$ -bench, ToolSandbox, BFCL	ContextBench $n=480$ ; $\tau$ -bench $n=72$ ; ToolSandbox $n=72$ ; BFCL $n=100$	Qwen3-Next-80B-A3B	Qwen3.5-9B	det.; $B=128$
Appendix diagnostic controls	ContextBench, ToolSandbox, $\tau$ -bench, BFCL; RepoBench; SWE-Lite	diagnostic supports: ContextBench $480$ ; ToolSandbox/ $\tau$ -bench $72$ ; BFCL $100$ ; RepoBench $480$ ; SWE-Lite $96$	Qwen3-Next-80B-A3B; Qwen3-Coder-Next-FP8 for SWE-Lite MA	Qwen3.5-9B	det.; $B=128$
OpenAI model-family extension	ContextBench, ToolSandbox, $\tau$ -bench, BFCL	stored API run summaries, $n=60$ – $300$ per displayed cell	gpt-5.4 in MA	six OpenAI receivers listed in Tables 18 – 19	API defaults; $B=128$
Selector diagnostic ablation	ContextBench	stored selector-ablation file, $n=300$	gpt-5.4	gpt-4o-mini	frozen selector
Static selector diagnostics	ToolSandbox, $\tau$ -bench	stored selector-policy files, $n=36$ per policy	Qwen3-Next-80B-A3B	Qwen3.5-9B	static selector policies
Budget/no-overflow diagnostics	ContextBench, ToolSandbox	paired diagnostic rows $480/72$ ; no-overflow subsets $100/39$	Qwen3-Next-80B-A3B	Qwen3.5-9B	det.; threshold $8192$ input tokens

Appendix

Table 6: Run bookkeeping for appendix numerical tables. The table records which support convention each appendix family uses. Main-text estimates use the supports stated in Table 1 . Appendix diagnostics use table-specific supports over stored model outputs, except for the explicitly marked OpenAI receiver-side budget sweep.

Benchmark	$n$	RO	SF	$\mathrm{MA}_{\rm main}$	$\mathrm{MA}_{\rm match}$	$\Delta_{\rm comm}$	$\Delta_{\rm cmp}$	$\Delta_{\rm strong}$
RepoBench	480	0.642	0.823	0.833	0.746	+0.192	+0.010	+0.088
SWE-bench Lite	96	0.000	0.052	0.521	0.000	+0.521	+0.469	+0.521

Appendix

Table 7: RepoBench and SWE-bench Lite appendix diagnostic breakdowns. Reported step-level rates on the stated supports. The released sender contrasts use common

(\mathrm{instance},\mathrm{step})

keys after the manifest’s duplicate policy is applied; the SWE-Lite seed mapping is specified above.

Benchmark	Contrast	Steps	Effect	95% CI
ContextBench	MA $-$ RO	2,390	$+0.1711$	$[0.1417,0.2012]$
RepoBench	MA $-$ RO	2,396	$+0.1611$	$[0.1340,0.1891]$
SWE-Lite	MA ${}_{\rm main}-$ MA match	96	$+0.5208$	$[0.3854,0.6563]$
$\tau$ -bench	MA $-$ RO	72	$0.0000$	$[-0.0833,+0.0694]$
BFCL	MA $-$ RO	100	$-0.2300$	$[-0.3900,-0.0800]$

Appendix

Table 8: Paired communication effects with uncertainty. Intervals are clustered by instance. Support is the number of paired steps; ContextBench and RepoBench contain 799 and 800 instances, respectively. The SWE-Lite contrast pairs instance-step keys across main-sender seed 2 and matched-sender seed 1.

Setting	Benchmark	Mean	Note
MA 80B $\to$ 80B	ToolSandbox	0.750	stronger receiver baseline
MA 80B $\to$ 397B	ToolSandbox	0.694	stronger receiver baseline
SF (80B receiver)	ToolSandbox	0.260	full-context baseline (80B receiver)

Appendix

Table 9: Receiver-scaling and SF controls on ToolSandbox. MA uses 80B or 397B receivers; SF uses an 80B receiver. These configurations complement the 9B receiver results in Table 1 .

Figure 8: Additional compression-effect controls. (a) Five-seed replication at temperature

0.3

on BFCL and ToolSandbox. (b) Stronger-receiver and SF controls on ToolSandbox.

Benchmark	Protocol	$n$	hit_joint	Message tok.	Total protocol input tok.	Trunc.	No-overflow
				mean / p90	mean / p90	rate	hit_joint
ContextBench	RO	480	0.633	0.0 / 0.0	6,899 / 12,267	0.000	0.610
ContextBench	SF	480	0.294	0.0 / 0.0	24,486 / 51,642	0.000	0.280
ContextBench	MA, $B{=}128$	480	0.775	127.2 / 128.0	16,365 / 28,160	0.842	0.790
ToolSandbox	RO	72	0.889	0.0 / 0.0	1,050 / 1,672	0.000	0.923
ToolSandbox	SF	72	0.903	0.0 / 0.0	1,273 / 2,054	0.000	0.923

Appendix

Table 10: Token accounting and no-overflow controls. Token counts are realized counts from the stored diagnostic records. The no-overflow column filters to paired rows where RO, SF, and MA all use at most 8192 protocol-level input tokens, giving

n=100

ContextBench rows and

n=39

ToolSandbox rows. These diagnostics use the stated appendix support and are not used as replacements for the main-text estimates.

Messages	Steps	RO	SF	MA	MA $-$ RO	MA $-$ SF
Capped	404	0.644	0.248	0.750	$+10.64$	$+50.25$
Uncapped	76	0.579	0.539	0.908	$+32.89$	$+36.84$

Appendix

Table 11: ContextBench accuracy by message truncation. Both groups use the same

B=128

protocol. The final two columns report paired accuracy differences in percentage points.

Benchmark	$B$	nano	mini	gpt-5.4	Mean
ContextBench	4	0.700	0.600	0.400	0.567
ContextBench	8	0.650	0.650	0.600	0.633
ContextBench	16	0.700	0.650	0.750	0.700
ContextBench	32	0.700	0.700	0.700	0.700
ContextBench	64	0.650	0.700	0.700	0.683
ContextBench	128	0.700	0.700	0.700	0.700

Appendix

Table 12: OpenAI receiver-side hard-sample budget sweep. Rows report hit_joint on 20 hard-sampled steps per benchmark and receiver alias, using stored Qwen sender messages and varying only the visible message budget. The hard sample prioritizes stored sender failures, sender-message truncation, and longer protocol inputs. The run completed 720 API calls with no failed calls.

Benchmark	$n$	Direct	Strict recode	Drop
BFCL	200	0.985	0.985	0.0 pp
ContextBench	100	1.000	0.940	6.0 pp
ToolSandbox	200	1.000	0.965	3.5 pp
$\tau$ -bench	155	1.000	0.865	13.5 pp

Appendix

Table 13: Direct versus strict recoded sender messages. The evaluated target

G_{t}

is unchanged across conditions; only the receiver-facing representation changes. Values are recomputed from the stored recoding-probe records on the stated diagnostic supports.

Figure 9: Gain-surrogate view of message utility. (a) Per-benchmark composition of the step-level hit-based proxy gain surrogate csi_sample , split into none, partial, and high bins. (b) Step-level hit_joint conditional on gain-surrogate bin. (c) Benchmark-level mean gain surrogate versus mean hit_joint . High-surrogate steps occur in both helpful and harmful communication regimes.

Figure 10: Additional replay and closure analyses. Panels report easy/hard replay partitions, replay stress across receivers, and RepoBench replay accuracy under frozen messages. The same decomposition remains evident: some receivers are primarily content-limited, whereas the main outliers are primarily closure-limited.

Receiver	Robust valid	Permissive valid	Wrong action
GLM-5	99.6	99.6	44.5
MiniMax-M2.5	86.8	87.0	94.0
o3	97.3	97.3	40.8

Appendix

Table 14: Parsing audit under a gpt-5.4 sender replay. Validity columns use all audited outputs. Wrong-action rates condition on valid parsing and a correct artifact. This is a separate sender condition from Table 2 . All entries are percentages.

Figure 11: Additional sender-threshold analyses. Panels show a ContextBench sender frontier, a sender-family accuracy matrix, and benchmark-level effects with a fixed receiver. Panel (c) uses $\Delta_{\rm align}=-\Delta_{\rm strong}$ , so positive values favor the matched sender.

Figure 12: Sender-replacement ablation (fixed Qwen3.5-9B receiver). (a) ContextBench sender ranking against RO and matched-sender references. (b) The same sender set on ToolSandbox. (c) Per-sender signed communication effect on ContextBench versus ToolSandbox. A sender that helps in one setting can hurt in another, so sender choice is a task-level protocol decision rather than a fixed ranking of models.

Fit	Anchors	Slope on RO	$R^{2}$	Crossover RO	95% CI
Linear	22	-0.449	0.492	0.638	[0.491, 0.780]
Segmented / hinge	22	piecewise	0.503	0.300	[0.300, 0.900]

Appendix

Table 15: Sender-upgrade threshold fit. The response is

\Delta_{\rm strong}=\mathrm{MA}_{\rm strong}-\mathrm{MA}_{\rm matched}

; RO accuracy is used as the observable local-sufficiency proxy. The negative fitted slope supports the theorem’s regime prediction: stronger senders help where local sufficiency is low and become tax-dominated where RO is high.

Analysis	Anchor set	Crossover	95% CI
Submitted fit	22	0.6376	$[0.491,0.780]$
Expanded fit	41	0.6289	$[0.552,0.706]$
Leave one benchmark family out	41	0.6451
Excluding SWE-Lite	41	0.6154

Appendix

Table 16: Expanded sender-upgrade crossover analysis. The response is

\Delta_{\rm strong}

and the predictor is receiver-only accuracy, as in Table 15 .

Sender $\to$ receiver	ContextBench acc.	$\Delta$ vs RO	ToolSandbox acc.	$\Delta$ vs RO
gpt-4o-mini $\to$ gpt-4o-mini	0.867	+0.217	0.960	+0.157
gpt-5.4-nano $\to$ gpt-5.4-nano	0.873	+0.380	0.960	+0.203
gpt-5.4-mini $\to$ gpt-5.4-mini	0.867	+0.253	0.913	+0.217

Appendix

Table 17: Within-family sender identity check. Rows use the same-family MA self-pairs from the stored OpenAI run. Deltas compare each self-pair against the receiver’s RO value for the same benchmark condition.

Benchmark	Receiver	$n_{\rm RO}/n_{\rm SF}/n_{\rm MA}$	RO $h_{j}$	SF $h_{j}$	MA $h_{j}$
ContextBench	gpt-4o-mini	300/300/300	0.650 [0.594,0.702]	0.743 [0.691,0.789]	0.787 [0.737,0.829]
ContextBench	gpt-5.4-nano	300/300/300	0.493 [0.437,0.550]	0.637 [0.581,0.689]	0.783 [0.733,0.826]
ContextBench	gpt-5.4-mini	300/300/300	0.613 [0.557,0.667]	0.770 [0.719,0.814]	0.787 [0.737,0.829]
ContextBench	gpt-5.4	300/300/150	0.600 [0.544,0.654]	0.777 [0.726,0.820]	0.853 [0.788,0.901]
ContextBench	o3	300/300/150	0.223 [0.180,0.274]	0.133 [0.099,0.176]	0.493 [0.414,0.573]
ContextBench	o4-mini	300/300/300	0.500 [0.444,0.556]	0.617 [0.561,0.670]	0.743 [0.691,0.790]

Appendix

Table 18: OpenAI model-family extension counts and Wilson intervals, ContextBench and ToolSandbox. Each entry is hit_joint with Wilson

95\%

interval over the stored step records for that diagnostic cell. MA uses gpt-5.4 as the sender; the stated counts are table-specific appendix supports.

Benchmark	Receiver	$n_{\rm RO}/n_{\rm SF}/n_{\rm MA}$	RO $h_{j}$	SF $h_{j}$	MA $h_{j}$
$\tau$ -bench	gpt-4o-mini	150/150/150	0.253 [0.190,0.328]	0.020 [0.007,0.057]	0.373 [0.300,0.453]
$\tau$ -bench	gpt-5.4-nano	150/150/150	0.313 [0.245,0.391]	0.233 [0.173,0.307]	0.300 [0.232,0.378]
$\tau$ -bench	gpt-5.4-mini	150/150/150	0.293 [0.226,0.371]	0.233 [0.173,0.307]	0.327 [0.257,0.405]
$\tau$ -bench	gpt-5.4	150/150/75	0.240 [0.179,0.314]	0.180 [0.127,0.249]	0.147 [0.084,0.244]
$\tau$ -bench	o3	75/75/75	0.200 [0.125,0.304]	0.173 [0.104,0.274]	0.160 [0.094,0.259]
$\tau$ -bench	o4-mini	150/150/75	0.273 [0.208,0.350]	0.280 [0.214,0.357]	0.160 [0.094,0.259]

Appendix

Table 19: OpenAI model-family extension counts and Wilson intervals,

\tau

-bench and BFCL. Each entry is hit_joint with Wilson

95\%

interval over the stored step records for that diagnostic cell. MA uses gpt-5.4 as the sender; the stated counts are table-specific appendix supports.

Figure 13: Cross-family ablations. (a) OpenAI model extensions on ContextBench. (b) OpenAI ToolSandbox. (c) ContextBench content/closure diagnostics across OpenAI and replay receivers. (d) Weak-family full-protocol baselines. (e) Five-seed replication at temperature

0.3

on BFCL and ToolSandbox. (f) Cross-family receiver summary on ContextBench. Each panel extends one of the three main claims under a different family, receiver scale, or protocol stress.

Selector variant	$n$	Acc.	Cost / send	Skip	Compress	Raw
Full score	300	0.737	0.536	175	11	114
No gain term	300	0.650	0.402	300	0	0
No tax term	300	0.737	0.536	175	11	114
No cost term	300	0.730	0.550	175	0	125
No residual term	300	0.737	0.536	175	11	114
Always skip	300	0.650	0.402	300	0	0

Appendix

Table 20: Selector ablation on ContextBench. Rows are computed from stored OpenAI RO/SF/MA records for the gpt-4o-mini receiver and gpt-5.4 sender on the stated diagnostic support. The comparison is an accuracy–cost frontier diagnostic: always-send has the highest raw accuracy in this static cell, while the full selector uses less than

0.54\times

the always-send cost and remains above always-skip.

Benchmark	Policy	hit_joint	Mean input tokens
ToolSandbox	adaptive selector	1.000	581
ToolSandbox	always skip	0.972	577
ToolSandbox	always send	0.806	2,474
ToolSandbox	always rewrite	0.833	1,930
$\tau$ -bench	adaptive selector	0.083	2,504
$\tau$ -bench	always skip	0.056	711

Appendix

Table 21: Static selector diagnostics on protocol-sensitive benchmarks. Rows are aggregated from the stored selector-policy records on the stated diagnostic supports. Token cost is realized total input tokens per step. These baselines complement the ContextBench term ablation in Table 20 .

	ToolSandbox			ContextBench
Condition	Acc.	$\Delta$ vs RO	Cost	Acc.	$\Delta$ vs RO	Cost
Receiver-only	0.889	0.000	1,374	0.633	0.000	7,251
MA (default)	0.653	-0.236	2,995	0.775	0.142	16,801
Prose	0.556	-0.333	2,905	0.694	0.061	4,183
Evidence-rewrite (knob set)	—	—	—	0.778	0.144	1,853
Canonical JSON	0.750	-0.139	3,004	0.764	0.131	4,162

Appendix

Table 22: Representative protocol ablations on a harmful and a helpful benchmark. The rows compare skip , bounded compress , evidence rewriting, and suppression under rewritten prompts and per-knob cost accounting. The evidence-rewrite row forwards a compact, normalized evidence bundle; its input and token cost differ from the full-context SF protocol in Table 1 .

Figure 14: Expanded protocol-knob analyses. Panels report the grounded rewrite matrix, broader budget sweeps, and selective-suppression controls.

Calibration fraction	5%	10%	20%	30%	40%
Mean accuracy	0.7368	0.7415	0.7425	0.7452	0.7458
Cost / always-send	0.5358	0.5366	0.5356	0.5372	0.5386

Appendix

Table 23: Selector sensitivity to calibration size. Each column averages 20 instance-disjoint calibration/test splits.

Policy	Accuracy	Tokens/step	Utility
Receiver-relative selector	0.7425	1,732.9	0.5692
Always raw	0.7517	2,151.7	0.5365
Multinomial logistic (always skip)	0.6525	1,300.0	0.5225
Gradient boosted	0.6617	1,425.3	0.5191
Learned centroid	0.7292	2,181.5	0.5110
Always send	0.7917	3,227.0	0.4690

Appendix

Table 24: ContextBench routing policies on a shared action set. Utility is accuracy minus

10^{-4}

times mean tokens.

	ContextBench			ToolSandbox
Policy	Accuracy	Tokens	Utility	Accuracy	Tokens
MasRouter (always-send)	0.6317	3,227	0.3090	0.7056	3,085

Appendix

Table 25: Separately reported MasRouter measurements. Token counts are per step; the utility column uses ContextBench accuracy and the

10^{-4}

token weight.

Policy	Step-runs	Accuracy	Tokens/step	Seconds/step
Pre-sender gate	36	1.000	919.4	6.60
Always send	36	0.8056	3,085.4	9.56
SKIP endpoint	720	0.9875	1,801.4	14.37
Always send	720	0.9861	4,282.4	19.42

Appendix

Table 26: ToolSandbox runtime measurements. Recorded tokens include prompt and completion tokens on the executed path. The 36-step input-only counts in Table 21 are 581 for the selector and 2,474 for always-send. The endpoint study used 144 steps across five seeds per policy.

Action	Scorer probes	Sender calls	Receiver generations
skip through gate	0	0	1
skip after scoring	9	2	1
raw	9	2	1
compress	9	2	1
refresh	9	2	1
escalate	9	2	1

Appendix

Table 27: Model calls for the gate and five-action selector. The gate precedes candidate construction. Each post-gate decision generates and caches both message candidates, uses nine probes capped at four tokens, and executes one receiver generation. escalate uses the stronger receiver; other actions use the base receiver.

Figure 15: Conditional propagation in shared-state tasks. (a) LongCLI-Bench: perturbations produce a persistent downstream deficit, and repair only partially closes it. (b) A higher-coupling ToolSandbox condition: downstream effects are visible, and repair helps but does not fully erase the gap. (c) A broader ToolSandbox condition: the deficit is largely local, and the trajectory quickly resynchronizes.

Figure 16: Fresh-observation ablation. (a) LongCLI-Bench: stale observations degrade downstream performance even without an injected perturbation, and targeted repair helps most under stale conditions. (b) ToolSandbox: fresh observations largely neutralize downstream perturbation effects in broader conditions, reinforcing the resynchronization interpretation.

Multi-Agent Communication

Multi-agent communication studies how autonomous agents exchange information to coordinate decisions, share knowledge, and act together under constraints.

See all 380 papers

When Do Multi-Agent Systems Help? An Information Bottleneck Perspective
Jul 17, 2026Wendi Yu, Lianhao Zhou, Xiangjue Dong +6Multi-Agent LLM Systems Information Bottleneck
Department of Computer Science & Engineering, Texas A&M University · Department of Electrical & Computer Engineering, Texas A&M University · Computing and Data Sciences Directorate, Brookhaven National Laboratory
When Upstream Messages Override Correct Answers: A Controlled Study of Multi-Agent LLM Collaboration
Sep 29, 2026Yaxin Gong, Gangyi Zhang, Chongming Gao +7Multi-Agent LLM Systems Multi-Agent Collaboration
University of Science and Technology of China · Qwen Business Unit of Alibaba · National University of Singapore
LatCom: Cross-Agent Latent Compression for Efficient Multi-Agent Collaboration
Sep 29, 2026Shinan Zhang, Tao Zhang, Qihui Zhu +7Multi-Agent LLM Systems Multi-Agent Collaboration
University of Science and Technology of China · Institute of Artificial Intelligence, Hefei Comprehensive National Science Center

Jul 17, 2026J/K move · Enter open · S save

When Do Multi-Agent Systems Help? An Information Bottleneck Perspective

Wendi Yu, Lianhao Zhou, Xiangjue Dong, Sai Sudarshan Barath+5

Department of Computer Science & Engineering, Texas A&M University · Department of Electrical & Computer Engineering, Texas A&M University · Computing and Data Sciences Directorate, Brookhaven National Laboratory

Multi-Agent LLM Systems Information Bottleneck Multi-Agent Systems Multi-Agent Communication

Open paper AskPDF arXiv

LLM powered multi-agent systems (MAS) have emerged as a promising paradigm for complex tasks. However, their advantages over single-agent systems (SAS) remain unclear, with performance varying inconsistently across settings. Here, we provide an information bottleneck perspective on elucidating the differences between MAS and SAS. Specifically, our key observation is that a SAS accumulates its full reasoning trace in one shared context, while a MAS uses isolated local contexts connected by bounded relay messages. We show that, under infinite relay bandwidth, any SAS can be simulated by a MAS that transmits the full upstream context. Thus, the nontrivial advantage of MAS arises under bounded relays, where compression introduces a fundamental trade-off: reducing redundant context can improve efficiency, but may also incur loss of task-relevant information. We formalize this trade-off as an information bottleneck controlled by an effective parameter

β

, which captures how the balance shifts with model capability, and shows that MAS gains arise when context reduction outweighs relay information loss. We conduct 18 controlled experiments across five benchmarks and three model scales to validate our theoretical studies. We observe that MAS consistently helps when relays are near-sufficient, especially for weaker models. In contrast, MAS gains shrink or reverse when relays incur information loss, especially for stronger models that can already extract useful information from redundant context and thus gain little from compression. Our study shows that multi-agent design is fundamentally an information-bottleneck optimization problem. This perspective explains when bounded inter-agent communication helps or hurts.

Abstract

Multi-Agent Communication

Explore similar work

When Do Multi-Agent Systems Help? An Information Bottleneck Perspective

When Upstream Messages Override Correct Answers: A Controlled Study of Multi-Agent LLM Collaboration

LatCom: Cross-Agent Latent Compression for Efficient Multi-Agent Collaboration