PRISM: Privileged Sibling-Guided Multi-Agent Topology Design

Overview of PRISM. Stage 0 fits the topology designer on execution-verified graphs, which also supply the privileged input a. Stage 1 trains a teacher whose FiLM branch reads a sibling graph. Stage 2 has the teacher rescore the student's own sampled trajectories, mixing a reverse-KL distillation loss with a supervised anchor. Stage 3 deploys the student alone to select agents and generate edges. — **Stage 0** fits the designer on execution-verified topologies, which also supply the privileged input \(a\). **Stage 1** trains a separate teacher whose FiLM branch reads \(a\). **Stage 2** has the teacher rescore the student's own trajectories. **Stage 3** deploys the student alone; the teacher is discarded.

TL;DR PRISM post-trains an autoregressive multi-agent topology designer with on-policy self-distillation from a teacher that sees a sibling graph (another verified topology that solved the same query). The teacher is dropped at deployment, so PRISM needs no extra MAS executions and no architecture change. It is the best topology designer on all six benchmarks.

6/6benchmarks best among topology designers

+13.78points over continued SFT on AQuA

0extra multi-agent executions in post-training

+1.0%LLM calls vs. ARG-Designer at deployment

Abstract

Multi-agent systems (MAS) based on large language models (LLMs) have become a powerful way to address complex problems, and their effectiveness depends critically on the collaboration topology that decides which agents participate and how they communicate. Recent work learns to generate this topology from the task query, fitting the generator to corpora of execution-verified graphs. The post-training method for such generators remains a limitation: a corpus lists the graphs that solved a query but never ranks them, leaving continued supervised fine-tuning (SFT) with no per-query preference to exploit. Without such a preference, the generator drifts toward the topologies the corpus contains most often rather than those that suit each query, so a gain on one task can come at a cost on another.

We propose PRISM, which recovers per-query signal from the same corpus by learning with privileged information: a teacher reads, through a zero-initialized low-rank branch, a sibling graph that also solved the query and is unavailable at deployment, and the student matches its per-decision targets on trajectories the student samples itself. Across six diverse benchmarks PRISM improves over every topology-design baseline evaluated, and matched-teacher controls support the contribution of privileged query information.

Motivation

A verified corpus says which graphs worked, but never which one is best. How do we post-train on it?

(a) Continued SFT

Fits the recorded graphs by teacher forcing, with no per-query preference among the several graphs that solved each query.
Concentrates the output distribution: the top-1 topology share doubles from 0.171 to 0.346.
Gains are uneven: +6.15 on GSM8K, but −12.60 on AQuA relative to ARG-Designer.
Supervises only recorded trajectories, so partial graphs the student reaches on its own get no supervision (exposure bias).

(b) PRISM

A teacher sees a sibling graph (another verified topology for the same query) as training-only privileged information.
The student samples its own graphs, and the teacher scores every node and edge decision on those student-visited partial graphs.
A supervised anchor keeps the student close to valid verified topologies.
Reuses the same corpus: no new MAS executions, and the deployed model is architecturally identical to ARG-Designer.

Method

MAS as a collaboration graph. Following ARG-Designer, a MAS is a directed acyclic graph \(G=(V,E)\) whose nodes are LLM agents with roles from an extensible pool \(\mathcal{R}\). An edge \(e_{ji}\) feeds agent \(v_j\)'s output into \(v_i\)'s prompt. The designer generates the graph autoregressively, one role and then its incoming edges at a time:

\[P_\theta(G\mid Q,\mathcal{R})=\prod_{i=1}^{|V|} \underbrace{P_\theta(v_i\mid G_{<i},Q,\mathcal{R})}_{\text{node generation}}\;\prod_{j=1}^{i-1}\underbrace{P_\theta(e_{ji}\mid v_i,G_{<i},Q)}_{\text{edge generation}}\]

The verified corpus \(\mathcal{D}\) holds every blueprint graph (chain, star, layered, fully-connected, mesh) that solved a training query. A query is typically solved by several distinct topologies, and none of them is marked as preferable.

STAGE 0 · COLD START

Fit the designer on verified graphs

ARG-Designer is trained on execution-verified query–graph pairs, giving the deployed checkpoint \(\theta_0\). The same corpus later supplies the privileged sibling graphs.

STAGE 1 · PRIVILEGED TEACHER

A clone that reads a sibling graph

The teacher is a copy of \(\theta_0\) whose conditioning vector is FiLM-modulated by a rank-16 encoding of a sibling graph \(a\):

\[c_{\text{teacher}}=\mathrm{TaskProc}(f_Q)\odot\big(1+\gamma(f_a)\big)+\beta(f_a)\]

The FiLM output is zero-initialized, so the teacher starts identical to the student. The sibling is drawn uniformly from the other verified graphs for the same query and resampled every epoch. The channel adds about 20k parameters.

STAGE 2 · ON-POLICY SELF-DISTILLATION

Correct the student where it actually goes

The student samples \(M=4\) complete topologies per query. The frozen teacher (with \(a\)) and the student (without \(a\)) rescore them. Their node and edge decision spaces are small and categorical, so the divergence is computed exactly:

\[\mathcal{L}_{\mathrm{KL}}=\alpha\,\mathbb{E}_{\text{node}}\!\left[\mathrm{KL}(P_\theta\|P_{\text{teacher}})\right]+(1-\alpha)\,\mathbb{E}_{\text{edge}}\!\left[\mathrm{KL}(P_\theta\|P_{\text{teacher}})\right]\]

\[\mathcal{L}_{\text{PRISM}}=(1-\lambda)\,\mathcal{L}_{\mathrm{KL}}+\lambda\,\underbrace{\big(-\log P_\theta(G_{\text{real}}\mid Q)\big)}_{\mathcal{L}_{\text{anchor}}}\]

Defaults are \(\alpha=0.2\), \(\lambda=0.3\) and reverse KL. Setting \(\lambda=1\) recovers the SFT control.

STAGE 3 · DEPLOYMENT

Student only, query only

The teacher and its privileged channel are discarded. The deployed student is architecturally identical to ARG-Designer: it selects agents and generates edges from the query alone. At \(K=1\) it uses 4.04 LLM calls per query, against 4.00 for ARG-Designer.

Benchmark Results

Main results

Pass@1 / accuracy (%) with Qwen2.5-7B-Instruct as the backbone for every agent; all arms were re-run under one execution stack. PRISM is the best method on every benchmark. Continued SFT tracks or beats ARG-Designer on five benchmarks but drops 12.60 points on AQuA, where PRISM instead gains.

Method	GSM8K	MultiArith	SVAMP	AQuA	HumanEval	MMLU	Avg.
Single agent
Vanilla	70.28	88.33	82.40	61.81	69.51	62.70	72.51
Topology design
AgentPrune	76.72	94.67	91.90	68.90	71.95	67.93	78.68
AgentDropout	77.86	95.33	92.20	70.47	77.44	68.32	80.27
G-Designer	78.01	97.33	91.80	74.41	78.05	71.52	81.85
ARG-Designer (baseline)	79.98	98.83	92.50	75.20	79.27	71.98	82.96
Post-training from the ARG-Designer checkpoint
SFT (control)	86.13	98.83	92.40	62.60	80.49	73.22	82.28
PRISM (Ours)	88.02	99.17	93.30	76.38	82.32	73.94	85.52

Seed variability

Mean ± sample standard deviation over three post-training runs (seeds 42, 43, 44) from the same checkpoint. PRISM leads SFT by 3.18 points on the benchmark average, an order of magnitude more than either arm's spread. SFT's average (82.31) sits below the checkpoint it starts from (83.03).

Arm	GSM8K	MultiArith	SVAMP	AQuA	HumanEval	MMLU
ARG-Designer	80.21 ± 0.75	98.33 ± 0.50	92.93 ± 0.51	75.33 ± 1.38	79.07 ± 0.35	72.28 ± 0.64
SFT	86.18 ± 0.09	98.83 ± 0.00	92.73 ± 0.42	62.73 ± 0.61	80.29 ± 0.35	73.09 ± 0.54
Constant teacher	86.71 ± 0.04	98.66 ± 0.29	92.37 ± 0.29	69.42 ± 1.94	81.51 ± 0.35	73.29 ± 1.02
PRISM (Ours)	87.77 ± 0.57	98.89 ± 0.26	93.47 ± 0.47	76.51 ± 1.38	82.52 ± 0.35	73.76 ± 0.55

Deployment cost

Mean per-query cost over the evaluation sets at \(K=1\). PRISM buys 2.56 and 3.24 points of average accuracy over ARG-Designer and SFT for 1.0% more LLM calls. Post-training adds no executions: its rollouts sample graph trajectories without running any agent.

Designer	Agents \|V\|	Edges \|E\|	LLM calls	Avg. accuracy
ARG-Designer	3.00	2.30	4.00	82.96
SFT	3.00	2.21	4.00	82.28
PRISM (Ours)	3.04	2.27	4.04	85.52

Controls and ablations

Compare

Pass@1 / accuracy (%); the y-axis starts at 50. Hover over a benchmark to see every arm's value. All arms post-train \(\theta_0\) with every other Stage-2 setting held fixed.

Why Does It Work?

The teacher reads the channel

On held-out graphs we score the same teacher with the channel on and off, \(\Delta=\log P_{\text{teacher}}(G\mid Q,a)-\log P_{\text{teacher}}(G\mid Q)\). A shuffle control matches the channel, parameter count and budget, but shows each query another query's graph.

Privilege gain on held-out graphs (nats)

Sibling (PRISM)2.45

Shuffled≈ 0

FiLM norm ‖film‖ after teacher training

Sibling (PRISM)3.10

Shuffled1.15

The shuffled FiLM branch does train (its norm rises from zero), yet its gain never leaves zero. The real channel's +2.45 nats therefore comes from what the channel carries, not from extra capacity.

Content, not just procedure

A constant teacher keeps on-policy distillation but holds the privileged input fixed. Separating the two effects on AQuA:

AQuA accuracy (%)

SFT62.60

Constant teacher71.65

PRISM (Ours)76.38

+9.05 from on-policy distillation, then +4.73 from privileged content.

Across all six benchmarks, PRISM beats the constant teacher (+1.66 on average, sign test \(p=0.031\)) under matched epochs, sampling, supervision, loss mixture and compute. The shuffled teacher is worse than constant on all six, so another query's graph actively misleads the student.

Less concentration, more query dependence

(a) Top-1 topology share ↓

0.171ARG-Designer (start)

0.346SFT

0.157PRISM

(b) Output variety explained by query ↑

1.1%Cold start

2.0%SFT

5.8%PRISM

SFT collapses onto a default crew

SFT's most frequent role assignment, [Math Solver, Programming Expert, Programming Expert], appears on roughly a third of questions on every math benchmark. PRISM lowers the top-1 topology share to 0.157. The query explains 5.8% of PRISM's output entropy (above a permutation null), against 2.0% for SFT.

Concentration is not a loss of vocabulary: the cold start emits 22 distinct shapes, SFT 40 and PRISM 34.

Difficulty-matched control

Questions are split by whether SFT emitted its default crew, and both arms are scored on exactly the same questions. On AQuA, PRISM improves in both groups, so the default crew explains part of the gap but not all of it.

Benchmark	Group	n	SFT	PRISM	Δ	McNemar p
GSM8K	SFT emitted default	460	87.4	88.5	+1.1	0.68
GSM8K	SFT emitted other	859	85.4	87.8	+2.4	0.15
SVAMP	SFT emitted default	371	91.6	94.6	+3.0	0.16
SVAMP	SFT emitted other	629	92.8	92.5	−0.3	0.92
AQuA	SFT emitted default	91	60.4	79.1	+18.7	0.0001
AQuA	SFT emitted other	163	63.8	74.8	+11.0	0.003

Qualitative Examples

The crew each designer builds on GSM8K problems (Qwen2.5-7B-Instruct), and the answer the resulting system returns.

BibTeX

@article{dat2026prism,
  title={PRISM: PRIvileged Sibling-Guided Multi-Agent Topology Design},
  author={Dat, Phuong Tuan and Li, Qi and Wang, Xinchao},
  journal={arXiv preprint arXiv:2610.20628},
  year={2026}
}