When a large language model (LLM) task is split across several cooperating model instances ("agents") — a planner, a coder, a tester, a critic — an early mistake does not stay put. Downstream agents treat what they receive as fact, so one bad premise can quietly reach the final answer. This is the "telephone game" failure documented for hierarchical pipelines such as MetaGPT and collaborative planners (Planning with Multi-Constraints via Collaborative Language Agents). Checking every agent's output is expensive, so the practical question is where a small checking budget should go. We propose spending it on the agents whose errors would travel furthest. We measure that reach with Bonacich centrality, a network-science score that counts every path from a node and discounts each path by the product of its edge weights. We compute it on a graph whose edge weights record how much each agent actually relied on each upstream message in this particular run.
The link between the two fields is direct rather than metaphorical. PropUQ-MAS already models how risk accumulates in an agent workflow through a recursive rule over parent nodes. If that rule is linearized, the sensitivity of the final answer's risk to any single agent's local uncertainty is exactly a Bonacich centrality on the reliance-weighted graph. This is the same quantity that, in The Network Origins of Large Economic Downturns, decides which sectors' small shocks become economy-wide crashes. PropUQ-MAS looks upstream: it asks how much inherited risk sits at node $v$. We look downstream: we ask how much of the answer's risk would disappear if node $v$ were repaired. We then use that score to place verification, under a fixed token budget, while the system runs.
Core Claim
Take a multi-agent run recorded as a directed acyclic graph of generation steps. PropUQ-MAS writes the propagated risk at step $v$ as $r_v = 1 - (1-u_v)\prod_{p \in Pa(v)}(1-\hat\alpha_{pv} r_p)$. Here $u_v$ is the step's own uncertainty, $Pa(v)$ is its set of parent steps, and $\hat\alpha_{pv}\in[0,1]$ is how strongly step $v$ accepted parent $p$'s message. When risks are small, the risk at the final step $s$ depends on each local uncertainty approximately linearly:
$$\frac{\partial r_s}{\partial u_v} \approx c_v = \big[(I - A)^{-1}\big]_{vs},\qquad A_{pv} = \hat\alpha_{pv}.$$
Here $A$ is the matrix of acceptance weights. The matrix $(I-A)^{-1}$ sums, over every path from $v$ to $s$, the product of acceptance weights along that path; it is finite because the graph has no cycles. This is the Bonacich centrality of $v$ toward the sink on the reliance graph. Our placement score is $u_v c_v$, the first-order reduction in final-answer risk from fully repairing step $v$.
The claim has two parts. First, at a matched token budget, repairing the steps with the highest $u_v c_v$ improves final accuracy more than repairing the steps with the highest local uncertainty, the highest propagated risk, or the highest purely structural centrality. Second, the gain comes from weighting edges by reliance as measured in each run, not from topology alone.
The second part is what separates this from the obvious idea of "verify the high-betweenness agent." Betweenness assumes that information moves along shortest paths, and the research file flags that assumption as poorly matched to conversational systems. A planner can sit at a structural bottleneck while its downstream agents largely ignore it. A side-channel critic can look peripheral while every later agent copies its output.
Research Program
We first build the instrumentation. We wrap existing multi-agent systems with the interception layer from AgentMonitor so that each run produces a trace graph. Its nodes are agent generation steps and its edges are messages actually consumed. AgentMonitor computes PageRank on such graphs, but only as an input to a regressor that predicts success. We reuse its logging, not its passive use of centrality. Each node gets a local uncertainty $u_v$ elicited as in PropUQ-MAS.
Each edge gets an acceptance weight, estimated in two ways. The cheap way is PropUQ-MAS's self-reported acceptance. The more grounded way is a counterfactual probe on a calibration subset: we replace the parent's message with a plausible corrupted version and measure how often the child's output changes.
The second component is an analysis study. On held-out problems we measure ground-truth downstream influence by error injection. For each node, we corrupt its output, re-execute the downstream steps that depend on it, and record whether the final answer flips. We then ask which score best predicts this injected influence. The candidates are reliance-weighted Bonacich centrality, unweighted betweenness and closeness, PageRank as used by AgentMonitor, degree, position in the pipeline, and PropUQ-MAS's upstream risk $r_v$.
The analysis is only informative on graphs that branch. In a plain chain every centrality reduces to position, so the study uses topologies with real branching. These are role pipelines in the style of MetaGPT, sparse graphs produced by AgentPrune, query-specific graphs produced by G-Designer, and the multi-round layered networks of DyLAN.
The third component is the intervention, which follows a run–score–repair protocol. The system executes once and computes $u_v c_v$ for every node. It then repairs the top-$k$ nodes: a critic agent reviews the node's output, the node regenerates with the critique, and only the downstream steps that depend on the repaired node are re-executed. All token costs are charged to the method, including the critic calls, the regeneration, and the re-executed downstream steps.
A cheaper variant estimates acceptance weights before execution, using averages per role pair learned on a small calibration set. This version can trigger repairs during the run, as soon as a node's uncertainty is known. It trades accuracy of the reliance estimate for lower latency, and we report both versions.
Baselines
The do-nothing reference is the base multi-agent system run once with no repair. Each topology family is run on the same backbone model and the same prompts.
The naive budget-matched reference spends the same extra tokens on independent re-runs of the whole system with majority voting. This is the multi-agent analogue of repeated sampling.
The strongest existing competitor for deciding where to check is placement driven by PropUQ-MAS. We repair the nodes with the highest propagated risk $r_v$, using exactly the same uncertainty elicitation, acceptance weights, critic, and repair procedure as our method, so the only difference is the ranking score. PropUQ-MAS reports average relative gains of +6.10% AUROC and +47.58% Prediction Rejection Ratio across GSM8K, MedQA, and MBPP-Plus. Those numbers are for detecting failures, not for repairing them. We found no reported result on Lacuna for PropUQ-MAS used as a repair-placement policy, so we construct and tune this baseline ourselves with the same budget for tuning thresholds as our method.
We also compare against two topology-learning systems run on their own terms: G-Designer, which reports 89.90% pass@1 on HumanEval, and DyLAN, which reports 82.9% pass@1 on HumanEval. Our method is a layer that can be added to either. The fair comparison is therefore G-Designer or DyLAN alone versus the same system with our repair layer, at reported tokens per query.
Three ablations isolate the key ingredient. The first ranks nodes by local uncertainty $u_v$ alone. The second ranks by structural Bonacich centrality with all acceptance weights set to one. The third ranks by unweighted betweenness. Beating the PropUQ-MAS ranking and the unit-weight ablation at $k=1$ and $k=2$, on at least two of the three benchmark families, with confidence intervals that do not overlap, counts as success.
Why not just…?
Why not just verify the final answer with best-of-$N$ sampling? Training Verifiers to Solve Math Word Problems shows that repeated sampling plus a verifier is strong; a 6B model with verification reached about 35% on GSM8K. The same paper notes that verifiers are fooled by right answers reached through flawed steps. Sampling at the end also cannot fix a planner error that every sample inherits when the pipeline is shared. The budget-matched voting baseline tests this directly. If it matches our method, then targeted repair has no value, and we will report that result.
Why not just check the node with the highest uncertainty, or the highest PropUQ risk? This is the real threat. Uncertainty-only placement ignores reach: a confident-looking but wrong leaf costs little, while a mildly uncertain planner that everyone copies costs a lot. Ranking by $r_v$ looks upstream, so it favours late nodes that have accumulated inherited risk, and those are the nodes where repair helps least. The prediction is falsifiable. If the injection study shows that $u_v$ or $r_v$ predicts flip influence as well as $u_v c_v$ does, the downstream term adds nothing and the proposal collapses into PropUQ-MAS.
Why not just use classical betweenness on the topology, as power-grid studies do? In Nodal vulnerability to targeted attacks in power grids, betweenness predicts collapse because current actually flows along those paths. In agent pipelines, whether a message is used varies from run to run. The unit-weight and betweenness ablations measure how much of the effect is pure structure. If structure alone suffices, the simpler static method wins and per-run reliance weights are unnecessary.
Why not just learn a better topology up front, as G-Designer or AgentPrune do? These systems fix the graph before execution and cannot respond to a failure in a particular run. Our layer is complementary to them, and testing on graphs they produce shows whether failures concentrated at a few nodes remain after a topology has been optimized.
Proposed Experiments
We evaluate on GSM8K, MedQA, and MBPP-Plus, which keep us directly comparable with PropUQ-MAS, and on HumanEval, which is comparable with G-Designer and DyLAN. Each benchmark is run across the four topology families with $k\in\{1,2,3\}$ repairs. We report accuracy or pass@1 against total tokens, plus Spearman correlation and precision@$k$ between each ranking score and the flip influence measured by injection.
The first decisive check is the injection study. Reliance-weighted Bonacich centrality must predict flip influence better than PropUQ-MAS risk, PageRank, and betweenness on branching topologies.
The second decisive check is the matched-token repair comparison at $k=1$. If the gain over the PropUQ-MAS ranking does not survive there, the idea fails.
A third, diagnostic check estimates acceptance weights from counterfactual probes instead of self-reports. Self-reported reliance may be poorly calibrated, much as the sycophancy findings in Peacemaker or Troublemaker would suggest. This check tells us whether the method's value depends on measuring reliance honestly rather than eliciting it.
References
- MetaGPT: Meta Programming for A Multi-Agent Collaborative Framework
- Planning with Multi-Constraints via Collaborative Language Agents
- The Network Origins of Large Economic Downturns
- Cut the Crap: An Economical Communication Pipeline for LLM-based Multi-Agent Systems
- G-Designer: Architecting Multi-agent Communication Topologies via Graph Neural Networks
- A Dynamic LLM-Powered Agent Network for Task-Oriented Agent Collaboration
- Training Verifiers to Solve Math Word Problems
- Nodal vulnerability to targeted attacks in power grids
- Peacemaker or Troublemaker: How Sycophancy Shapes Multi-Agent Debate