Paper deep dive
SIGMA: Skill-Incidence Graphs for Compositional Multi-Agent Design
Kun Zeng, Yu Huo, Siyu Zhang, Yuecheng Zhuo, Yuquan Lu, Haoyue Liu, Siyue Chen, Xiaoying Tang
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 98%
Last extracted: 6/20/2026, 4:58:56 AM
Summary
SIGMA (Skill-Incidence Graphs for Compositional Multi-Agent Design) is a framework that shifts multi-agent system (MAS) design from fixed-role agents to task-conditioned bundles of reusable skills. It utilizes a Skill-Incidence Multi-Agent Protocol (SI-MAP) to predict a skill-agent incidence matrix, allowing agents to be constructed as dynamic compositions of 'skill cards'. This approach enables better generalization to unseen capabilities and tasks. The framework separates capability composition (what an agent can do) from topology decoding (how agents communicate) and uses skill-specific mailboxes for operational execution. Experimental results across six benchmarks (including HumanEval, MMLU, and GSM8K) using three LLM backbones (Qwen3-8B, GPT-OSS-120B, GPT-4o-mini) demonstrate that SIGMA outperforms non-compositional baselines like CARD.
Entities (10)
Relation Signals (6)
SIGMA → evaluatedon → HumanEval
confidence 100% · We evaluate SIGMA on six representative benchmarks... HumanEval
SIGMA → evaluatedon → MMLU
confidence 100% · We evaluate SIGMA on six representative benchmarks... MMLU
SIGMA → evaluatedon → GSM8K
confidence 100% · We evaluate SIGMA on six representative benchmarks... GSM8K
SIGMA → implements → SI-MAP
confidence 100% · To instantiate SI-MAP, we introduce SIGMA, a compositional and executable LLM-powered multi-agent graph designer.
SIGMA → outperforms → CARD
confidence 100% · SIGMA achieves the best average performance and improves over CARD... by 2.06, 2.36, and 1.75 points, respectively.
SIGMA → uses → Skill Card
confidence 100% · SIGMA represents reusable capabilities as skill cards
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Existing graph-based multi-agent system (MAS) designers mainly improve collaboration by optimizing communication topologies over predefined agents, roles, or groups. However, because each node remains a closed-set entity, these methods struggle to generalize to tasks that require unseen combinations of capabilities. We propose SIGMA, a skill-incidence graph framework that constructs agents as task-conditioned bundles of reusable skills. Given a task and a skill library, SIGMA predicts a skill-agent incidence matrix, composes agent node embeddings from selected skills, and decodes a communication topology over the constructed agents. During execution, skill-specific mailboxes route messages to the relevant assigned capabilities, making the incidence structure directly operational. Across six reasoning and coding benchmarks with three base LLMs, SIGMA achieves the best average performance and improves over CARD, the strongest non-compositional topology-based baseline, by 2.06, 2.36, and 1.75 points, respectively. It also shows stronger robustness to unseen skill libraries, with an average performance drop of only 0.96 points. These results suggest that compositional node construction is a complementary and important axis for multi-agent design beyond communication topology optimization. Code is available at this https URL.
Tags
Links
- Source: https://arxiv.org/abs/2606.19758v1
- Canonical: https://arxiv.org/abs/2606.19758v1
Trouble viewing inline? Open PDF directly →
Full Text
107,474 characters extracted from source content.
Expand or collapse full text
SIGMA: Skill-Incidence Graphs for Compositional Multi-Agent Design Kun Zeng ♣ * , Yu Huo ♠ * , Siyu Zhang ♠ , Yuecheng Zhuo ♢ , Yuquan Lu ♣ , Haoyue Liu ♠ , Siyue Chen ♡ , Xiaoying Tang ♠† ♠ School of Science and Engineering, The Chinese University of Hong Kong, Shenzhen ♣ Sun Yat-sen University ♡ South China University of Technology ♢ Taiyuan University of Technology Abstract Existing graph-based multi-agent system (MAS) designers mainly improve collaboration by optimizing communication topologies over predefined agents, roles, or groups. However, because each node remains a closed-set entity, these methods struggle to generalize to tasks that require unseen combinations of capabil- ities. We propose SIGMA, a skill-incidence graph framework that constructs agents as task- conditioned bundles of reusable skills. Given a task and a skill library, SIGMA predicts a skill- agent incidence matrix, composes agent node embeddings from selected skills, and decodes a communication topology over the constructed agents. During execution, skill-specific mail- boxes route messages to the relevant assigned capabilities, making the incidence structure di- rectly operational. Across six reasoning and coding benchmarks with three base LLMs, SIGMA achieves the best average performance and improves over CARD, the strongest non- compositional topology-based baseline, by 2.06,2.36, and1.75points, respectively. It also shows stronger robustness to unseen skill libraries, with an average performance drop of only0.96points. These results suggest that compositional node construction is a comple- mentary and important axis for multi-agent de- sign beyond communication topology optimiza- tion. Code is available athttps://anonymous. 4open.science/r/SIGMA-2338/. 1 Introduction Large language model based multi-agent systems (MAS) solve complex tasks by assigning agents specialized roles and communication structures (Li et al., 2023a; Wu et al., 2024; Hong et al., 2024; Qian et al., 2024; Chen et al., 2024). Recent graph-based designers further automate this pro- cess by learning task-adaptive topologies over * Equal contribution † Corresponding author Figure 1: Comparison between fixed-role and skill- composed multi-agent graph design. agent nodes (Liu et al., 2024; Zhuge et al., 2024; Zhang et al., 2025b,a). Yet most of them still regard each node as a closed-set role, operation, or pre- defined group: they optimize how existing agents communicate, while leaving what each agent is able to do largely fixed. This node-level rigidity limits compositional generalization. Real tasks often require capabil- ities that cross role boundaries, including tool use and intermediate actions (Karpas et al., 2022; Yao et al., 2022), API grounding and structured tool access (Li et al., 2023b; Patil et al., 2023; Qin et al., 2024), and reusable procedural skills (Wang et al., 2023). Such capabilities are not always aligned with a single role. Although fixed roles are useful abstractions, they do not explicitly construct new agent identities from reusable capabilities. Con- sequently, a topology designer can learn a better graph over predefined agents, but it cannot make the same slot become a retrieval-grounded imple- menter for one task and a verification-heavy rea- soner for another. In light of this dilemma, we propose the LLM- based Skill-Incidence Multi-Agent Protocol (SI- 1 arXiv:2606.19758v1 [cs.MA] 18 Jun 2026 Figure 2: Performance plot across six benchmarks and three base LLMs. MAP), which provides guidance for compositional LLM-MA graph design: Skill-Incidence Multi-Agent Protocol (SI- MAP): Given a taskqand skill libraryL, a compositional LLM-MA designer should sat- isfy: (1) Compositionality, constructing each agent as a task-conditioned skill bundle; (2) Executability, making assigned skills affect prompts, tools, memory, or routing; (3) Topol- ogy compatibility, exposing constructed node representations to a graph decoder; and (4) Ex- pandability, allowing new tool/API skill cards at test time without retraining the topology de- coder. To instantiate SI-MAP, we introduce SIGMA, a compositional and executable LLM-powered multi-agent graph designer. SIGMA represents reusable capabilities as skill cards, predicts a task- conditioned skill-agent incidence matrix, composes node embeddings from the selected cards, and de- codes a communication topology over the con- structed agents. During execution, the same inci- dence structure is exposed through skill-specific mailboxes, so skill assignments are operational rather than latent annotations. This design de- liberately separates two decisions that are cou- pled in role-based systems: what each agent can do is decided by skill incidence, whereas how agents exchange information is decided by topol- ogy decoding. The separation lets SIGMA keep the matched-crew evaluation protocol of prior graph- based MAS work while testing a different model- ing axis, namely whether reusable capabilities can construct more transferable agent nodes. Figure 2 provides a compact preview of our empirical find- ings. The formal objects and full algorithms are given in Section 3, Section 4, and Appendix B. Our contribution can be summarized as follows: ❶Protocol Proposal. We propose SI-MAP, a proto- col that shifts graph-based MAS design from con- necting fixed agents to constructing executable agent nodes from reusable skills. It formalizes compositionality, executability, topology com- patibility, and expandability as requirements for skill-aware multi-agent graph design. ❷ Practical Solution. We present SIGMA, which couples incidence-based node construction, skill- aware topology decoding, and mailbox-based ex- ecution under matched multi-agent settings. Un- like methods that only prune or reconnect prede- fined nodes, SIGMA changes the capability com- position of each node before topology generation. ❸Experimental Validation. We evaluate SIGMA against single-agent, debate-based, and topology- based multi-agent baselines under compositional generalization settings. The evaluation isolates whether skill incidence improves compositional generalization under the same crew size, con- text budget, and graph-decoding interface. As summarized by Figure 2, SIGMA achieves consis- tently strong performance across diverse bench- marks, suggesting that the gains are not tied to a specific backbone or task family. 2 Related Work LLM-based multi-agent systems. LLM-based multi-agent systems decompose complex tasks into interacting agents with specialized roles, work- flows, and communication protocols. Role-playing frameworks assign agents complementary identi- ties, enabling them to collaborate through instruc- tion following, perspective taking, and iterative communication (Li et al., 2023a; Chen et al., 2024). Workflow-oriented systems further organize agents into structured pipelines, where different agents are responsible for planning, coding, reviewing, testing, or project management (Wu et al., 2024; Hong et al., 2024; Qian et al., 2024). Another work improves reasoning by introducing debate, discussion, or self-reflection among multiple LLM agents, allowing agents to expose errors and refine intermediate answers through interaction (Du et al., 2024; Liang et al., 2024). Multi-agent frameworks have also been applied to simulation and decision- making scenarios (Park et al., 2023). Graph-based Multi-agent Design.Graph-based MAS methods mainly improve collaboration by adapting the communication topology among predefined agents.One line of work designs task-adaptive or dynamic connections between agents (Liu et al., 2024; Zhuge et al., 2024). An- other line treats the graph itself as an optimiz- 2 able or learnable object, using graph search or graph decoders to produce task-conditioned topolo- gies (Zhang et al., 2025b; Wu et al., 2026). Recent work further studies conditional topology design, where the communication graph adapts to chang- ing environmental signals such as model capabil- ity, tool availability, or knowledge-source varia- tion (Wu et al., 2026). Pruning-based methods instead reduce redundant communication by re- moving unnecessary agents or edges (Zhang et al., 2025a). These methods make communication more flexible than hand-written chains or fully connected graphs, but the agent nodes are still largely fixed. Tool-augmented and skill-based agents. Tool- augmented agents extend LLMs with external exe- cutable procedures (Karpas et al., 2022; Yao et al., 2022; Schick et al., 2023; Shen et al., 2023; Li et al., 2023b; Patil et al., 2023; Qin et al., 2024). Skill- library agents further show that reusable skills can be stored and adapted across tasks (Wang et al., 2023). 3 Preliminaries 3.1 Graph-Based Multi-Agent Design For a task queryq, a graph-based MAS withK agent slots is represented as a directed graph G q = (A,E q ), whereA =a 1 ,...,a K denotes agent slots and E q denotes directed communication edges. Its adja- cency matrixA q ∈0, 1 K×K satisfiesA q [i,j] = 1if messages froma i are passed toa j . Conven- tional role-based systems initialize each agent as an atomic entity, a k =Base k , Role k , State k , Plugin k ,(1) where the role/profile and tool configuration deter- mine the node semantics. This interface supports topology learning, but it leaves the node vocabu- lary closed-set. Given a generated graphG q , agents communicate forTrounds. At roundt, an agent receives the task query and messages produced by its in-neighbors in the previous round: R (t) k = a k P (t) k,sys ,P (t) k,usr , P (t) k,usr = n q,R (t−1) j : a j ∈N in (a k ) o , (2) whereN in (a k )is the in-neighborhood ofa k and R (0) j is initialized as an empty message. After the final round, an aggregation function returns the system answer: ˆy q ← Aggregate R (T) 1 ,...,R (T) K .(3) SIGMA keeps this graph-execution interface, sum- marized in Appendix B.2, while replacing atomic role nodes with skill-composed nodes. 3.2 Skill-Agent Incidence LetL = s 1 ,...,s M be a library of reusable skills, and letSdenote the corresponding set of skill-card nodes when we form skill-agent bipartite graphs. Definition 1 (Skill Card). A skill card is a reusable capability descriptor s m = (n m ,d m ,η m ,κ m ,g m ),(4) wheren m is the skill name,d m is its natural- language description,η m is an executable affor- dance such as a tool, API endpoint, retrieval oper- ation, or reasoning procedure,κ m is an optional input-output contract, andg m records the ground- ing source. Purely cognitive skills are still in- stantiated as concrete prompt-level procedures or mailbox routing targets, preventing vague role la- bels from being treated as executable skills. Each card is embedded by a frozen encoder ase m = Enc(s m )∈ R d . For a queryq, SIGMA constructs theKagent slots through a skill-agent incidence matrix B q ∈0, 1 M×K , B q [m,k] = 1⇐⇒ s m 7→ a k . (5) Thek-th column defines the executable skill bundle L q,k =s m ∈L| B q [m,k] = 1.(6) Thus,a k is no longer a single role token; it is a task-conditioned bundle of selected capabilities. Definition 2 (Skill-Incidence MAS). Given a query q, a skill libraryL, andKagent slotsA = a 1 ,...,a K , a skill-incidence multi-agent system is X q = (L,A, B q , U q ,G q ,M q ),(7) whereB q is the executable skill-agent incidence matrix,U q contains bundle embeddings used by the graph decoder,G q is the decoded communi- cation graph, andM q is the set of skill-specific mailboxes. A deployed skill-incidence MAS re- quires that each nonempty bundle is grounded in 3 Figure 3: Framework of SIGMA. Offline, an incidence generator is trained with deterministic pseudo-label supervision to assign reusable skills to agent slots. Online, the predicted task-specific incidence matrix is converted into skill-composed agent embeddings, which are used to decode an agent communication graph with skill-specific message routing. skill cards, each node embedding is computed from the selected cards, and every incident pair(m,k) owns an execution-time mailbox. This separates capability composition from topology generation:B q determines what each agent can do, whileG q determines how the con- structed agents communicate. The definition de- scribes the discrete system used at inference and execution. During training, SIGMA optimizes a continuous relaxation whose hard projection yields B q ; this preserves differentiability without chang- ing the executable object evaluated at test time. 4 Methodology 4.1 Overview Figure 3 illustrates the overall framework of SIGMA. SIGMA treats reusable skills as first-class design objects. Given a queryqand a skill library L, it first predicts a skill-agent incidence structure: (z q , E) = SkillEncode(q,L), (P q , B q ) = F θ (z q , E), H q = (S,A, B q ). (8) It then constructs skill-composed agents, decodes their communication topology, and executes the resulting graph: (U q , Ω q ) = Construct(H q , z q , E), G q = D φ,ψ (U q , Ω q , E, z q ), ˆy q = Execute(G q , B q ,q). (9) HereP q is the soft incidence matrix used for learn- ing,B q is the hard executable incidence matrix, H q is the induced skill-agent bipartite graph, and Ω q stores skill-attention weights. The learnable components are the incidence generatorF θ and the skill-aware topology decoderD φ,ψ . The full de- coding algorithm and implementation details are provided in Appendix B. 4.2 Incidence Generation and Agent Construction Each skill card is serialized using the fields in Defi- nition 1 and encoded together with the query by a frozen text encoder: z q = Enc(q), e m = Enc(s m ), E = [e 1 ,..., e M ] ⊤ . (10) 4 The frozen encoder lets new tool/API cards enter at test time by extendingL, rather than changing the model architecture. For each skills m and slota k , the incidence gen- erator computes α m,k = F θ ([z q , e m , p k , z q ⊙ e m ]),(11) wherep k is a learned embedding for thek-th canon- ical agent slot and⊙denotes element-wise product. The soft incidence probability is P q [m,k] = σ(α m,k ).(12) For notational brevity, we writep m,k = P q [m,k] below. Soft incidence provides supervision and a differentiable training path, while the hard matrix B q determines executable bundles. We obtainB q through a deterministic sparse projection. For each slotk, SIGMA first forms the thresholded candidate set C q,k =m : σ(α m,k ) > τ skill .(13) It then selects at mostk s skills, with an argmax fallback when no skill exceeds the threshold: I q,k = ( Top k s (C q,k ;α ·,k ), C q,k ̸=∅, arg max m α m,k , otherwise. (14) We setB q [m,k] = 1iffm∈I q,k . If two slots pro- duce the same bundle, the later slot is repaired by re- placing the lowest-margin duplicated skill with the highest-scoring unused skill. This avoids repeated agents under a fixed crew size; Appendix B.4 gives the complete algorithm. The hard incidence matrix defines a skill-agent bipartite graphH q = (S,A, B q ). For each slot, SIGMA computes query-conditioned attention over selected skills: β m,k = B q [m,k] exp(α m,k ) P M ℓ=1 B q [ℓ,k] exp(α ℓ,k ) . (15) During training, an analogous soft support is used for differentiability.LetJ q,k = Top r c (1,...,M;α ·,k )be the top-ranked candi- date set with r c ≥ k s . The soft attention is ̃ β m,k = 1[m∈J q,k ]p m,k exp(α m,k ) P ℓ∈J q,k p ℓ,k exp(α ℓ,k ) .(16) Belowω m,k denotes ̃ β m,k during training andβ m,k during inference, andΩ q = [ω m,k ]. The node embedding combines slot identity, task context, and selected skill cards: u q,k = Norm p k + z q + M X m=1 ω m,k e m ! . (17) The resulting node matrix is U q = [u q,1 ,..., u q,K ] ⊤ ∈ R K×d .(18) It is consumed by the topology decoder under the same crew sizeKas role-based graph baselines. Thus, a node is not a pooled role embedding; its semantics are determined by the task and by exe- cutable skills assigned to the slot. 4.3 Skill-Aware Topology Decoding SIGMA decodes communication edges from both node-level affinity and skill-bundle compatibility. For each ordered pair(i,j), the agent-level affinity is r ij = MLP φ ([u q,i , u q,j , z q , u q,i ⊙ u q,j ]). (19) The skill-bundle compatibility aggregates pairwise complementarity between selected skills: g mnq = MLP ψ ([e m , e n , z q , e m ⊙ e n ]), c ij = X m,n ω m,i ω n,j g mnq . (20) The compatibility term captures task-specific com- plementarity such as retrieval skills feeding API grounding, planning skills feeding code writing, or testing skills feeding debugging. The sum is evalu- ated only over sparse active supports:J q,i ×J q,j during training and the Cartesian product of hard- selected skills during inference. Thus, the active compatibility cost depends on bundle size rather than the full library. The final edge logit combines both terms with a weak workflow prior: ℓ ij = r ij + λ c c ij + λ 0 A 0 [i,j], i̸= j,(21) whereA 0 is a simple anchor topology such as a chain, star, or dataset-provided workflow prior. Set- tingλ c = 0recovers a matched decoder that ig- nores explicit skill-pair compatibility. At inference time, edge probabilities are thresholded as G q = (A,E q ), E q =(a i ,a j ) : σ(ℓ ij ) > γ e , i̸= j. (22) If a benchmark requires a directed acyclic schedule, a canonical slot-order mask is applied before thresh- olding. This decoder remains topology-compatible 5 with prior graph-based MAS methods because it consumes the constructed node matrixU q and outputs the same type of directed communication graph. 4.4 Execution and Learning SIGMA usesB q during execution as well as repre- sentation learning. For each incident pair(m,k), the executor maintains a skill-specific mailbox; in- coming messages are routed to the most relevant assigned skills using frozen embedding similarity, and only the corresponding mailbox summaries enter the agent prompt. Thus, skill incidence af- fects prompts, tools, memory organization, and message routing instead of remaining a hidden vari- able. Formally, for each incident pair(m,k)with B q [m,k] = 1, SIGMA creates M (t) q,k,m =r : r → (a k ,s m ), time(r) < t, (23) wherer → (a k ,s m )indicates that messageris routed to skills m inside slota k . A frozen router scores incoming messageragainst each incident skill by γ m (r) = sim(Enc(r), e m ),(24) and routes it to the top-r s assigned skills. At round t, the system prompt contains the selected skill cards and state, while the user prompt contains the task and mailbox summaries: s (t) q,k = Summarize(M (t) q,k ), P (t) k,sys =L q,k , State (t) k , P (t) k,usr = n q, s (t) q,k o . (25) Each mailbox summary is capped under the same total context budget used by the baselines. Ap- pendix C gives the full prompt format and fallback routing. Training uses pseudo-labelsB ⋆ q built only from training-split role descriptions, tool/API docu- ments, and execution traces. For each training slot, a deterministic labeler retrieves candidate skills and selects at mostk s cards, yielding canonical incidence columns without using held-out queries, answers, traces, or inserted tool/API cards. The incidence generator is trained with binary cross- entropy: L inc = X q M X m=1 K X k=1 BCE B ⋆ q [m,k],p m,k . (26) When annotated communication graphs are avail- able, the topology decoder is trained with an edge reconstruction loss: L edge = X q X i̸=j BCE(A ⋆ q [i,j],σ(ℓ ij )).(27) In our benchmark setting, datasets do not provide ground-truth communication edges; thereforeA ⋆ q is instantiated from the same weak anchor topology A 0 used across controlled graph baselines, rather than from held-out answers or evaluation traces. We further use a soft bundle-size cap and graph sparsity penalty, L sparse = X q K X k=1 max 0, M X m=1 p m,k − k s ! + λ g X q X i̸=j σ(ℓ ij ). (28) The final objective is L =L inc + λ e L edge + λ s L sparse .(29) If annotated target graphs are unavailable,L edge is computed against this shared structural prior or omitted in the matched-decoder control. Pseudo- label construction and complexity analysis are de- tailed in Appendix D and Appendix F. At test time, SIGMA can use the frozen training library or ap- pend new cards derived from held-out tool/API documents, because new skills enter through the same text-card encoder. 5 Experiments 5.1 Setup Benchmarks. We evaluate SIGMA on six rep- resentative benchmarks covering code generation, general knowledge, mathematical reasoning, and symbolic problem solving:❶Code Generation: HumanEval (Chen et al., 2021);❷General Rea- soning: MMLU (Hendrycks et al., 2020);❸Math- ematical Reasoning: GSM8K (Cobbe et al., 2021), SVAMP (Patel et al., 2021), MultiArith (Roy and Roth, 2015), and AQuA (Ling et al., 2017). For all benchmarks, we report task accuracy as the primary metric. To examine whether the proposed method is robust across model scales and families, we con- duct experiments with three base LLMs: Qwen3- 8B (Yang et al., 2025), GPT-OSS-120B (Agarwal et al., 2025), and GPT-4o-mini (Hurst et al., 2024). The average score across all benchmarks is also 6 Table 1: Performance comparison with three different base LLMs. Mul., Topo., and Comp. indicate whether the method supports multi-agent execution, communication-topology design, and skill-based composition, respectively. Dark blue cells denote thebestand light blue cellssecond-bestresults. Cross, mixed check–cross, and check marks indicate no, partial, and full support. MethodMul.Topo.Comp.MMLUGSM8KMultiArithSVAMPAQuAHumanEvalAvg. Qwen3-8B Vanilla✗57.7180.7687.3796.6835.8382.2373.43 CoT✗58.74 ↑1.03 90.75 ↑9.99 87.83 ↑0.46 97.01 ↑0.33 81.10 ↑45.27 82.85 ↑0.62 83.05 ↑9.62 LLM-Debate ✓✗59.61 ↑1.90 90.12 ↑9.36 88.46 ↑1.09 97.62 ↑0.94 81.14 ↑45.31 83.85 ↑1.62 83.47 ↑10.04 GPTSwarm✓ ✗ ✗59.58 ↑1.87 89.78 ↑9.02 90.27 ↑2.90 97.85 ↑1.17 81.52 ↑45.69 84.14 ↑1.91 83.86 ↑10.43 G-Designer✓✗60.07 ↑2.36 90.85 ↑10.09 90.14 ↑2.77 98.45 ↑1.77 82.08 ↑46.25 84.73 ↑2.50 84.39 ↑10.96 ARG-Designer✓✗60.92 ↑3.21 91.14 ↑10.38 89.38 ↑2.01 98.21 ↑1.53 82.47 ↑46.64 85.47 ↑3.24 84.60 ↑11.17 CARD ✓✗60.13 ↑2.42 91.87 ↑11.11 90.54 ↑3.17 98.13 ↑1.45 81.92 ↑46.09 87.28 ↑5.05 84.98 ↑11.55 SIGMA✓61.44 ↑3.73 91.56 ↑10.80 98.39 ↑11.02 98.68 ↑2.00 83.46 ↑47.63 88.71 ↑6.48 87.04 ↑13.61 GPT-OSS-120B Vanilla✗81.5884.4995.9095.0774.7790.0486.98 CoT✗83.39 ↑1.81 84.81 ↑0.32 95.63 ↓0.27 95.19 ↑0.12 76.02 ↑1.25 90.87 ↑0.83 87.65 ↑0.68 LLM-Debate✓✗82.92 ↑1.34 85.53 ↑1.04 95.72 ↓0.18 94.89 ↓0.18 75.38 ↑0.61 91.43 ↑1.39 87.65 ↑0.67 GPTSwarm✓ ✗ ✗83.59 ↑2.01 86.88 ↑2.39 96.50 ↑0.60 94.77 ↓0.30 77.41 ↑2.64 92.30 ↑2.26 88.58 ↑1.60 G-Designer✓✗85.06 ↑3.48 88.62 ↑4.13 96.86 ↑0.96 95.21 ↑0.14 78.13 ↑3.36 92.88 ↑2.84 89.46 ↑2.49 ARG-Designer ✓✗85.63 ↑4.05 91.08 ↑6.59 98.67 ↑2.77 94.81 ↓0.26 78.62 ↑3.85 93.47 ↑3.43 90.38 ↑3.41 CARD✓✗85.78 ↑4.20 93.44 ↑8.95 98.21 ↑2.31 95.48 ↑0.41 82.76 ↑7.99 93.98 ↑3.94 91.61 ↑4.63 SIGMA✓87.28 ↑5.70 96.25 ↑11.76 98.34 ↑2.44 95.94 ↑0.87 90.16 ↑15.39 95.83 ↑5.79 93.97 ↑6.99 GPT-4o-mini Vanilla✗67.6185.3393.9486.1269.8077.2980.02 CoT✗68.84 ↑1.23 86.51 ↑1.18 94.46 ↑0.52 86.89 ↑0.77 71.85 ↑2.05 78.64 ↑1.35 81.20 ↑1.18 LLM-Debate ✓✗69.66 ↑2.05 87.29 ↑1.96 94.97 ↑1.03 87.67 ↑1.55 72.93 ↑3.13 79.48 ↑2.19 82.00 ↑1.99 GPTSwarm ✓ ✗ ✗71.40 ↑3.79 88.88 ↑3.55 96.01 ↑2.07 89.21 ↑3.09 75.06 ↑5.26 81.39 ↑4.10 83.66 ↑3.64 G-Designer✓✗73.19 ↑5.58 90.46 ↑5.13 96.78 ↑2.84 90.37 ↑4.25 76.58 ↑6.78 82.67 ↑5.38 85.01 ↑4.99 ARG-Designer ✓✗74.23 ↑6.62 91.84 ↑6.51 97.56 ↑3.62 91.53 ↑5.41 78.16 ↑8.36 84.54 ↑7.25 86.31 ↑6.30 CARD✓✗75.07 ↑7.46 93.13 ↑7.80 96.94 ↑3.00 91.62 ↑5.50 80.40 ↑10.60 85.11 ↑7.82 87.05 ↑7.03 SIGMA✓76.47 ↑8.86 93.20 ↑7.87 99.11 ↑5.17 93.85 ↑7.73 83.86 ↑14.06 86.29 ↑9.00 88.80 ↑8.78 reported as an overall measure of general task- solving ability. All methods use the same bench- mark splits, deterministic decoding, and dataset- specific answer extractor; Appendix H.2 reports the concrete Vanilla and CoT prompt templates used in the evaluation. For MMLU, we follow the cost-controlled evaluation protocol used byG- Designerand ARG-Designer: all methods are evaluated on the same fixed 153-question shuffled subset, while training/optimization uses separate examples and never uses held-out answers. Baselines.We compare SIGMA with both single- agent and multi-agent baselines.For single- agent settings, we use Vanilla prompting and CoT (Wei et al., 2022).For multi-agent set- tings, we include LLM-Debate (Du et al., 2024), GPTSwarm (Zhuge et al., 2024), ARG- Designer (Li et al., 2026), CARD (Wu et al., 2026), andG-Designer(Zhang et al., 2025b). These baselines evaluate whether SIGMA’s gains come from skill-composed node construction rather than stronger prompting, additional agents, or topology optimization alone. Table 6 also displays more Figure 4: Performance drop from source skill libraries to unseen skill libraries. Lower values indicate stronger robustness to library changes. training and experiment details of SIGMA. 5.2 Main Results Superior Overall Performance. The results in Table 1 show that SIGMA consistently improves multi-agent collaboration across different model scales and task domains. Across Qwen3-8B, GPT- OSS-120B, and GPT-4o-mini, SIGMA achieves the highest average scores of87.04,93.97, and 88.80, respectively. Compared with CARD, the strongest non-compositional topology-based base- line in terms of average performance, SIGMA 7 Figure 5: Visualization of the accuracy and token trade- off across benchmarks. brings consistent average improvements of2.06↑, 2.36↑, and1.75↑points. It ranks first on16of the18benchmark–model combinations, with espe- cially clear gains on AQuA and HumanEval, where structured reasoning and executable construction matter. These results indicate that the gains of SIGMA are robust across baselines and bench- marks. To further isolate whether the improve- ments come merely from exposing task-relevant skill cards to the model, we also introduce SINGLE- AGENT+SKILLS, a controlled baseline that re- ceives the same union of selected skill cards as SIGMA but removes multi-agent execution, topol- ogy decoding, and mailbox routing. As a controlled baseline, SINGLE-AGENT+SKILLS improves over CoT but remains below SIGMA on average and on most datasets in Appendix Table 9, suggesting that the gains come not only from exposing skill cards, but also from topology-aware multi-agent execution and mailbox routing. Generalization to unfamiliar skill libraries. When the source skill library is replaced with un- seen skill cards at test time, SIGMA suffers the smallest average degradation. As shown in Ta- ble 14 and Figure 4, its performance drops by only0.96points, lower than CARD (2.03),G- Designer(3.00), GPTSwarm (4.06), and LLM- Debate (4.02). This robustness is especially evi- dent on MMLU, AQuA, and HumanEval, where topology-centric baselines exhibit much larger per- formance drops under library shifts. The result indicates that skill incidence can compose unseen cards into agent slots instead of relying on a fixed capability inventory. Efficiency. Figure 5 shows that SIGMA reaches the best accuracy with the fewest tokens among compared multi-agent methods on MMLU, Hu- manEval, GSM8K, and AQuA. Compared with GPTSwarm, it reduces token consumption by 95.5%,61.9%,92.9%, and60.3%on these bench- marks, respectively; compared with LLM-Debate, the maximum reduction reaches96.7%. Thus, SIGMA improves collaboration efficiency by com- posing task-specific agents rather than increasing communication volume; detailed statistics are in Appendix G.2. 5.3 Ablation Study Table 2 ablates the main components of SIGMA. ■w/o Inc. replaces the learned skill-agent inci- dence predictor with flat skill assignment.■w/o Skill Dec.,■w/o Mailbox, and■w/o Anchor Prior remove skill-aware decoding, mailbox routing, and the weak workflow prior, respectively. The con- sistent drops show that SIGMA’s generalization comes from the joint effect of compositional node construction, skill-aware topology decoding, and executable skill routing. Table 2: Ablation study under source and unseen skill libraries, using GPT-OSS-120B VariantMMLUHumanEval SourceUnseenSourceUnseen SIGMA85.6284.3195.9795.16 w/o Inc.80.3980.3991.2390.77 w/o Skill Dec.83.0182.3592.3392.41 w/o Mailbox81.0480.3993.0792.18 w/o Anchor Prior83.0183.6693.7492.93 6 Conclusion We presented SIGMA, a skill-incidence framework for compositional multi-agent design. Rather than treating agents as fixed role nodes, SIGMA con- structs each agent as a task-conditioned bundle of reusable skills and decodes communication over these skill-composed nodes. Skill-specific mail- boxes further make the incidence structure exe- cutable during multi-agent interaction. By separat- ing capability composition from topology genera- tion, SIGMA enables fixed agent slots to express diverse task-specific identities and generalize to unseen skill combinations. Our results highlight that effective multi-agent design should consider not only how agents communicate, but also how their internal capabilities are composed. 8 Limitations We note several limitations.❶SIGMA depends on the quality and coverage of the skill library, making noisy or incomplete skill cards a potential source of error.❷Its deterministic pseudo-labels and canon- ical slot ordering may inherit biases from labeling heuristics.❸The current framework assumes a fixed number of agent slots, leaving dynamic crew- size prediction as future work.❹Our evaluation focuses on benchmark-style reasoning and coding tasks, while real-world tool-use environments may involve noisier APIs, longer horizons, and skills with side effects.❺Finally, although skill-specific mailboxes make skill incidence executable, adap- tive routing and conflict resolution remain open directions. SIGMA does not attempt to solve the globally op- timal skill-agent assignment problem by exhaustive search. Instead, it learns a task-conditioned inci- dence generator and applies a sparse deterministic projection, trading global optimality guarantees for scalability under a fixed bundle-size budget. References Sandhini Agarwal, Lama Ahmad, Jason Ai, Sam Alt- man, Andy Applebaum, Edwin Arbus, Rahul K Arora, Yu Bai, Bowen Baker, Haiming Bao, and 1 others. 2025. gpt-oss-120b & gpt-oss-20b model card. arXiv preprint arXiv:2508.10925. Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde De Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, and 1 others. 2021. Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374. Weize Chen, Yusheng Su, Jingwei Zuo, Cheng Yang, Chenfei Yuan, Chi-Min Chan, Heyang Yu, Yaxi Lu, Yi-Hsin Hung, Chen Qian, and 1 others. 2024. Agent- verse: Facilitating multi-agent collaboration and ex- ploring emergent behaviors. In International Confer- ence on Learning Representations. Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, and 1 others. 2021.Training verifiers to solve math word problems.arXiv preprint arXiv:2110.14168. Yilun Du, Shuang Li, Antonio Torralba, Joshua B Tenen- baum, and Igor Mordatch. 2024. Improving factual- ity and reasoning in language models through multia- gent debate. In Forty-first international conference on machine learning. Dan Hendrycks, Collin Burns, Steven Basart, Andy Zou, Mantas Mazeika, Dawn Song, and Jacob Steinhardt. 2020. Measuring massive multitask language under- standing. arXiv preprint arXiv:2009.03300. Sirui Hong, Mingchen Zhuge, Jonathan Chen, Xiawu Zheng, Yuheng Cheng, Jinlin Wang, Ceyao Zhang, Steven Yau, Zijuan Lin, Liyang Zhou, and 1 others. 2024. Metagpt: Meta programming for a multi-agent collaborative framework. In International Confer- ence on Learning Representations. Aaron Hurst, Adam Lerer, Adam P Goucher, Adam Perelman, Aditya Ramesh, Aidan Clark, AJ Ostrow, Akila Welihinda, Alan Hayes, Alec Radford, and 1 others. 2024. Gpt-4o system card. arXiv preprint arXiv:2410.21276. Ehud Karpas, Omri Abend, Yonatan Belinkov, Barak Lenz, Opher Lieber, Nir Ratner, Yoav Shoham, Hofit Bata, Yoav Levine, Kevin Leyton-Brown, and 1 oth- ers. 2022. Mrkl systems: A modular, neuro-symbolic architecture that combines large language models, external knowledge sources and discrete reasoning. arXiv preprint arXiv:2205.00445. Guohao Li, Hasan Hammoud, Hani Itani, Dmitrii Khizbullin, and Bernard Ghanem. 2023a. Camel: Communicative agents for “mind” exploration of large language model society. Advances in neural information processing systems, 36:51991–52008. Minghao Li, Yingxiu Zhao, Bowen Yu, Feifan Song, Hangyu Li, Haiyang Yu, Zhoujun Li, Fei Huang, and Yongbin Li. 2023b. Api-bank: A comprehensive benchmark for tool-augmented llms. In Proceedings of the 2023 conference on empirical methods in natu- ral language processing, pages 3102–3116. Shiyuan Li, Yixin Liu, Qingsong Wen, Chengqi Zhang, and Shirui Pan. 2026. Assemble your crew: Auto- matic multi-agent communication topology design via autoregressive graph generation. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 40, pages 23142–23150. Tian Liang, Zhiwei He, Wenxiang Jiao, Xing Wang, Yan Wang, Rui Wang, Yujiu Yang, Shuming Shi, and Zhaopeng Tu. 2024. Encouraging divergent thinking in large language models through multi-agent debate. In Proceedings of the 2024 conference on empiri- cal methods in natural language processing, pages 17889–17904. Wang Ling, Dani Yogatama, Chris Dyer, and Phil Blun- som. 2017. Program induction by rationale genera- tion: Learning to solve and explain algebraic word problems. In Proceedings of the 55th annual meet- ing of the association for computational linguistics (volume 1: Long papers), pages 158–167. Zijun Liu, Yanzhe Zhang, Peng Li, Yang Liu, and Diyi Yang. 2024. A dynamic llm-powered agent network for task-oriented agent collaboration. In First Con- ference on Language Modeling. 9 Joon Sung Park, Joseph O’Brien, Carrie Jun Cai, Mered- ith Ringel Morris, Percy Liang, and Michael S Bern- stein. 2023. Generative agents: Interactive simulacra of human behavior. In Proceedings of the 36th an- nual acm symposium on user interface software and technology, pages 1–22. Arkil Patel, Satwik Bhattamishra, and Navin Goyal. 2021. Are NLP models really able to solve simple math word problems? In Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pages 2080–2094, Online. Association for Computational Linguistics. Shishir G Patil, Tianjun Zhang, Xin Wang, and Joseph E Gonzalez. 2023. Gorilla: Large language model connected with massive apis. arXiv preprint arXiv:2305.15334. Chen Qian, Wei Liu, Hongzhang Liu, Nuo Chen, Yufan Dang, Jiahao Li, Cheng Yang, Weize Chen, Yusheng Su, Xin Cong, and 1 others. 2024. Chatdev: Com- municative agents for software development. In Pro- ceedings of the 62nd annual meeting of the associa- tion for computational linguistics (volume 1: Long papers), pages 15174–15186. Yujia Qin, Shihao Liang, Yining Ye, Kunlun Zhu, Lan Yan, Yaxi Lu, Yankai Lin, Xin Cong, Xiangru Tang, Bill Qian, and 1 others. 2024. Toolllm: Facilitating large language models to master 16000+ real-world apis. In International Conference on Learning Rep- resentations. Subhro Roy and Dan Roth. 2015. Solving general arith- metic word problems. In Proceedings of the 2015 conference on empirical methods in natural language processing, pages 1743–1752. Timo Schick, Jane Dwivedi-Yu, Roberto Dessì, Roberta Raileanu, Maria Lomeli, Eric Hambro, Luke Zettle- moyer, Nicola Cancedda, and Thomas Scialom. 2023. Toolformer: Language models can teach themselves to use tools. Advances in neural information process- ing systems, 36:68539–68551. Yongliang Shen, Kaitao Song, Xu Tan, Dongsheng Li, Weiming Lu, and Yueting Zhuang. 2023. Hugging- gpt: Solving ai tasks with chatgpt and its friends in hugging face. Advances in Neural Information Processing Systems, 36:38154–38180. Guanzhi Wang, Yuqi Xie, Yunfan Jiang, Ajay Man- dlekar, Chaowei Xiao, Yuke Zhu, Linxi Fan, and Anima Anandkumar. 2023. Voyager: An open-ended embodied agent with large language models. arXiv preprint arXiv:2305.16291. Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Fei Xia, Ed Chi, Quoc V Le, Denny Zhou, and 1 others. 2022. Chain-of-thought prompting elic- its reasoning in large language models. Advances in neural information processing systems, 35:24824– 24837. Qingyun Wu, Gagan Bansal, Jieyu Zhang, Yiran Wu, Beibin Li, Erkang Zhu, Li Jiang, Xiaoyun Zhang, Shaokun Zhang, Jiale Liu, and 1 others. 2024. Au- togen: Enabling next-gen llm applications via multi- agent conversations. In First conference on language modeling. Tongtong Wu, Yanming Li, Ziye Tang, Chen Jiang, Linhao Luo, Guilin Qi, Shirui Pan, and Gholamreza Haffari. 2026. Card: Towards conditional design of multi-agent topological structures. arXiv preprint arXiv:2603.01089. An Yang, Anfeng Li, Baosong Yang, Beichen Zhang, Binyuan Hui, Bo Zheng, Bowen Yu, Chang Gao, Chengen Huang, Chenxu Lv, and 1 others. 2025.Qwen3 technical report.arXiv preprint arXiv:2505.09388. Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik Narasimhan, and Yuan Cao. 2022. React: Synergizing reasoning and acting in language models. arXiv preprint arXiv:2210.03629. Guibin Zhang, Yanwei Yue, Zhixun Li, Sukwon Yun, Guancheng Wan, Kun Wang, Dawei Cheng, Jeffrey Yu, and Tianlong Chen. 2025a. Cut the crap: An economical communication pipeline for llm-based multi-agent systems. In International Conference on Learning Representations. Guibin Zhang, Yanwei Yue, Xiangguo Sun, Guancheng Wan, Miao Yu, Junfeng Fang, Kun Wang, Tianlong Chen, and Dawei Cheng. 2025b. G-designer: Ar- chitecting multi-agent communication topologies via graph neural networks. In International Conference on Machine Learning, pages 76678–76692. PMLR. Mingchen Zhuge, Wenyi Wang, Louis Kirsch, Francesco Faccio, Dmitrii Khizbullin, and Jürgen Schmidhuber. 2024. Gptswarm: Language agents as optimizable graphs. In Forty-first International Conference on Machine Learning. 10 A Appendix Roadmap This appendix provides additional details for SIGMA, including method design, skill-card se- rialization, incidence decoding, mailbox execution, pseudo-label construction, evaluation protocols, im- plementation settings, and additional robustness results. Appendix Roadmap Appendix B: Method Details Additional method details, including graph execu- tion, skill-card serialization, hard incidence decod- ing, continuous relaxation, and end-to-end infer- ence. Appendix C: Mailbox Execution Skill-mailbox execution, mailbox summary format, and fallback routing. Appendix D: Pseudo Labels Deterministic pseudo-label construction and canon- ical slot ordering. Appendix E: Experimental Protocol Matched-crew evaluation, held-out skill composi- tion, test-time skill insertion, baselines, and met- rics. Appendix F: Implementation Details Hyperparameters, training configuration, training objective, and complexity analysis. Appendix G: Additional Results Additional results, including robustness to unfamil- iar skill libraries. Appendix H: Prompt Templates Prompt templates for SIGMA agent execution, Vanilla/CoT baselines, and dataset-specific answer extraction. Appendix I: Additional Details More details about datasets, skill libraries, and models used in experiments. Appendix J: Failure Cases Analysis of some failure cases during experiments. Appendix K: Impact Statement Impact of SIGMA. Appendix L: Case Study Detailed, card-style replay of representative Hu- manEval cases from the raw execution logs. Table 3: Operational checklist for the SI-MAP protocol. Each check corresponds to a required property of exe- cutable skill-incidence based multi-agent design, with its concrete realization in SIGMA summarized on the right. PropertyInstantiation in SIGMA CompositionalityBuilds each agent slot from a task-conditioned bundle of reusable skill cards via the incidence matrix B q . ExecutabilityExposes assigned skills through prompts, tool affordances, retrieval procedures, and skill-specific mailboxes. TopologyCom- patibility Feeds skill-composed agent embeddings U q into the same graph decoder used for communication topology generation. ExpandabilityAllows new tool/API skill cards to be appended at test time and encoded by the frozen skill encoder. B Additional Method Details B.1 SI-MAP Design Checklist The Skill-Incidence Multi-Agent Protocol (SI- MAP) requires that a graph-based multi-agent de- signer satisfies four operational properties. Table 3 summarizes how SIGMA instantiates these proper- ties. B.2 Graph Execution Interface The main text keeps only the compact graph def- inition. For completeness, we state the generic multi-agent execution interface used by SIGMA and the baselines. Given a generated graphG q , agents communicate forTrounds. At roundt, agenta k receives the task query and messages produced by its in-neighbors: R (t) k = a k P (t) k,sys ,P (t) k,usr , P (t) k,usr = n q,R (t−1) j : a j ∈N in (a k ) o , (30) whereN in (a k )is the in-neighborhood ofa k and R (0) j is initialized as an empty message. After the final round, an aggregation function returns the system answer: ˆy q ← Aggregate R (T) 1 ,...,R (T) K .(31) SIGMA keeps this interface but replaces atomic role nodes with skill-composed nodes and routes messages through skill-specific mailboxes. 11 B.3 Skill Card Serialization Each skill card is serialized into a fixed textual template before being encoded. We use the same template for training, validation, and test-time skill insertion. SKILL CARD TEMPLATEtag Skill_id "unique skill identifier" Name "skill name" Description "capability description" Benchmark "target benchmark or task domain" Inputs ["input field 1", "..."] Outputs ["output field 1", "..."] Tools ["optional tool/API/retrieval resource", "..."] Tags ["retrieval tag 1", "..."] SKILL CARD EXAMPLE Immlu Skill_id "option_elimination" Name "Option elimination" Description Rule out implausible multiple-choice answers before selecting the final answer. Benchmark "MMLU" Inputs ["query", "messages"] Outputs ["analysis", "answer"] Tools [] Tags ["mmlu", "multiple-choice", "elimination"] SKILL CARD EXAMPLE I aqua Skill_id "synthesize" Name "Synthesize" Description Produce the final response by consolidating the reasoning trajectory into a concise answer. Benchmark "AQuA" Inputs ["query", "messages"] Outputs ["analysis", "answer"] Tools [] Tags ["aqua", "synthesis", "final-answer"] SKILL CARD EXAMPLE IIIhumaneval Skill_id "algorithm_design" Name "Algorithm design" Description Choose an algorithmic strategy and complexity target before implementing the solution. Benchmark "HumanEval" Inputs ["query", "messages"] Outputs ["analysis", "answer"] Tools [] Tags ["humaneval", "algorithm", "complexity"] For tool or API skills, the executable affordance field contains the callable endpoint, retrieval oper- ation, or tool-use instruction. For cognitive skills, the affordance is instantiated as a concrete prompt- level procedure or mailbox-routing target rather than a vague role description. This prevents purely latent role labels from being treated as reusable executable skills. B.4 Hard Incidence Decoding The incidence generator predicts a soft assignment probabilityP q [m,k]for every skill-agent pair. The executable incidence matrixB q is obtained by de- terministic sparse projection. For each agent slotk, we first keep skills whose probability exceedsτ skill and then retain at mostk s skills. If no skill exceeds the threshold, the highest-scoring skill is used as an argmax fallback. To avoid repeated agent identi- ties under a fixed crew size, duplicated bundles are repaired by replacing the lowest-margin duplicated skill with the highest-scoring unused skill. Algorithm 1 SIGMA incidence decoding Require:Query embeddingz q , skill embeddingsE, slot embeddingsp k K k=1 , incidence generatorF θ , threshold τ skill , bundle size k s Ensure: Hard incidence matrix B q ∈0, 1 M×K 1: Initialize B q ← 0 2: for k = 1 to K do 3:for m = 1 to M do 4:α m,k ← F θ ([z q ,e m ,p k ,z q ⊙ e m ]) 5:p m,k ← σ(α m,k ) 6:end for 7: C q,k ←m : p m,k > τ skill 8:if C q,k ̸=∅ then 9:I q,k ← Top k s (C q,k ;α ·,k ) 10:else 11:I q,k ←arg max m α m,k 12:end if 13:for m∈ I q,k do 14:B q [m,k]← 1 15:end for 16: end for 17: Repair duplicated columns ofB q by replacing the lowest- margin duplicated skill with the best unused skill for the affected slot. 18: return B q B.5 Continuous Relaxation and Bundle Attention During training, SIGMA uses a sparse continuous relaxation aligned with the hard bundle. For each slotk, letJ q,k = Top r c (1,...,M;α ·,k )be the top-ranked candidate support withr c ≥ k s . The soft bundle attention is ̃ β m,k = 1[m∈J q,k ]p m,k exp(α m,k ) P ℓ∈J q,k p ℓ,k exp(α ℓ,k ) ,(32) wherep m,k = σ(α m,k ). We use ̃ β m,k during dif- ferentiable training and the hard-selected attention 12 β m,k during inference. The same sparse support is used when computing skill-bundle compatibil- ity, so pairwise skill interactions are evaluated over J q,i ×J q,j during training and over hard-selected skill products during inference. B.6 End-to-End Inference Procedure Algorithm 2 gives the complete inference proce- dure. SIGMA first constructs the task-specific skill- agent incidence matrix, builds incidence-aware agent embeddings, decodes the communication graph, and then executes the graph with skill- specific mailboxes. Algorithm 2 SIGMA inference Require:Queryq, skill libraryL, number of agent slotsK, encoderEnc, incidence generatorF θ , topology decoder D φ Ensure: Final answer ˆy q 1: z q ← Enc(q) 2: e m ← Enc(s m ) for each s m ∈L 3: B q ← INCIDENCEDECODE(z q ,E,F θ ) 4: for k = 1 to K do 5:Compute skill attentionβ m,k over selected skills with B q [m,k] = 1 6: u q,k ← Norm(p k + z q + P m β m,k e m ) 7: end for 8: U q ← [u q,1 ,...,u q,K ] ⊤ 9: for each ordered pair (i,j) with i̸= j do 10:Compute agent affinity r ij 11:Compute skill-bundle compatibility c ij 12: ℓ ij ← r ij + λ c c ij + λ 0 A 0 [i,j] 13: end for 14: E q ←(a i ,a j ) : σ(ℓ ij ) > γ e ,i̸= j 15: Create one mailboxM q,k,m for every incident pair(m,k) with B q [m,k] = 1 16: for t = 1 to T do 17:for each agenta k in the communication schedule do 18:Route incoming messages to the top-r s incident skill mailboxes. 19:Build the system prompt from selected skill cards and state. 20:Build the user prompt fromqand mailbox sum- maries. 21:Generate response R (t) k . 22:end for 23: end for 24: ˆy q ← Aggregate(R (T) 1 ,...,R (T) K ) 25: return ˆy q C Skill-Mailbox Execution The mailbox mechanism makes the incidence ma- trix executable during multi-agent interaction. For each incident pair(s m ,a k ), SIGMA maintains a skill-specific mailboxM q,k,m . When a message ar- rives at agenta k , the router compares the message embedding with the embeddings of skills assigned toa k and routes the message to the top-r s relevant mailboxes. The agent prompt then receives com- pact summaries of these mailboxes instead of a flattened context containing all messages. Formally, for every incident pair(m,k)with B q [m,k] = 1, the mailbox at round t is M (t) q,k,m =r : r → (a k ,s m ), time(r) < t, (33) wherer → (a k ,s m )means that messageris routed to skills m inside agenta k . A frozen router scores each incident skill by γ m (r) = sim(Enc(r), e m ),(34) and routesrto the top-r s skills among those as- signed toa k . At roundt, the prompt is constructed as s (t) q,k = Summarize(M (t) q,k ), P (t) k,sys =L q,k , State (t) k , P (t) k,usr = n q, s (t) q,k o . (35) Each mailbox summary is capped atbtokens, and all baselines are evaluated under the same total context budget. C.1 Mailbox Summary Format We use a fixed summary format for each mailbox: SIGMA MAILBOXrouted evidence Box Mailbox[skill] Src slot id, sim=score Signal answer / evidence / tool output Summary routed message summary Hint next-step usage SIGMA MAILBOX EXAMPLE Iproblem_decomposition Box Mailbox[problem_decomposition] Src slot 0, sim=0.087 Signal answer = C Summary The predecessor agent identifies option C as the best answer. Its analysis suggests that the question asks for a skill that is not central to planning. It contrasts conceptual, analytical, and communication skills with IT and computing skills, arguing that the latter are useful but less fundamental in the planning context. Hint Use this routed message to decompose the decision into core planning skills and non-essential supporting skills. The summary budget is capped bybtokens per mailbox. Baselines are given the same total context 13 budget, so the mailbox design changes only mes- sage organization rather than increasing available context. SIGMA MAILBOX EXAMPLE I elimination Box Mailbox[elimination] Src slot 0, sim=0.102 Signal answer = C Summary The predecessor agent selects option C and supports it by eliminating less plausible alternatives. The analysis argues that IT and computing skills, although useful, are not the most fundamental management skills for effective planning. Hint Use this routed evidence to rule out options describing useful but non-core planning skills, while keeping option C as the strongest candidate. C.2 Fallback Routing If all router scores are low or the selected agent has only one assigned skill, the message is routed to the highest-scoring incident skill. In implemen- tation, we also keep a lightweight general state for each agent slot, but only skill-specific mailbox summaries are exposed as capability-grounded ex- ecution context. This fallback prevents message loss while preserving the operational meaning of the incidence matrix. D Pseudo-Label Construction D.1 Training Skill Library The training skill libraryL train is constructed only from training-split sources, including role descrip- tions, tool/API documents, retrieval procedures, and execution traces. Held-out queries, held-out answers, held-out execution traces, and held-out tool/API cards are not used during pseudo-label construction. D.2 Deterministic Incidence Pseudo-Labels For each training task, we construct a deter- ministic pseudo-label incidence matrixB ⋆ q using teacher_light_label. These labels are not hu- man annotations and are not generated by an LLM. The labeler retrieves the topR = 8candidate skills fromL train and assigns at mostk s = 3skills to each of theK = 5agent slots. The selected skills define the columns ofB ⋆ q and provide supervision for the incidence predictor. The label files do not contain ground-truth com- munication edges. Therefore, when edge super- PSEUDO-LABEL EXAMPLE "id": "mmlu-val-abstract_algebra-0", "query": "The cyclic subgroup of Z_24 generated by 18 has order Option A: 4 Option B: 8 Option C: 12 Option D: ...", "S": [ ["analogy", "counterexample", " domain_translation"], ["counterexample", "domain_translation ", "problem_decomposition"] ], "B": [ [0, 0, 0, 0, 0], [0, 0, 0, 0, 1], [0, 0, 0, 0, 0], [1, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 0, 1, 1, 1], [1, 1, 0, 0, 0], [0, 0, 0, 1, 1], [0, 0, 0, 0, 0], [1, 1, 1, 0, 0] ] Figure 6: Example pseudo-label for skill-agent inci- dence supervision. The fieldSrecords task-relevant skill groups, whileBis a binary incidence matrix indi- cating which skills are assigned to each agent slot. vision is needed during training, we use a chain prior as structural supervision rather than assuming annotated edge labels. D.3 Pseudo-Label Format The deterministic pseudo-labeler outputs selected skill names for each slot. The output is stored in a lightweight JSON-style format: PSEUDO-LABEL TEMPLATEincidence supervision Id benchmark split and example id Query task input or question text S task-relevant skill groups or candidate skill sets B binary skill-agent incidence matrix, where B i,k = 1 assigns skill i to agent slot k Here is an example: Figure 6 D.4 Canonical Slot Ordering Pseudo-label columns follow the canonical slot or- der used by the training pipeline. This avoids intro- ducing an additional bipartite matching objective 14 between predicted slots and target agents. When multiple assignments are equivalent, ties are re- solved deterministically by the labeler. E Experimental Protocol E.1 Matched-Crew Evaluation All compared methods use the same number of agent slotsK, the same communication-round bud- getT, and the same total context budget. This ensures that the comparison isolates how agent nodes are constructed and how messages are routed, rather than allowing gains from larger crews or longer contexts. E.2 Held-Out Skill-Composition Setting The held-out skill-composition setting evaluates whether a method can solve tasks requiring unseen combinations of skills. Training tasks and test tasks may share individual skill cards, but the specific multi-skill bundles required at test time are held out from training. This setting measures compositional generalization over reusable capabilities. As shown in I.4 E.3 Test-Time Skill-Insertion Setting The test-time skill-insertion setting evaluates whether a trained designer can use newly appended tool/API skills without retraining the topology de- coder. At test time, new skill cards are serialized with the same template as training cards and en- coded by the frozen encoder. The incidence gener- ator and skill-aware topology decoder then operate over the expanded libraryL train ∪L new . A method succeeds in this setting only if it can assign the newly inserted skills to appropriate agent slots and use them during execution. This distin- guishes genuine expandability from merely memo- rizing training-time role or tool configurations. E.4 Baselines and Controlled Variants We compare SIGMA with role-based, topology- based, and skill-based controls. The key controlled variants are summarized in Table 4. E.5 Evaluation Metrics The primary metric is downstream task accuracy under the same evaluator used by each benchmark. We also report the source-to-unseen performance drop: ∆ = Acc source − Acc unseen .(36) Table 4: Baselines and controlled variants used in our experimental protocol. CategoryMethodControlled Design Factor Multi-agent baselines LLM-DebateUses role-specialized agents for argument exchange, without explicit reusable skill assignment. Topology baselines GPTSwarmOptimizes communication structures over predefined agents, but does not predict skill-agent incidence. G-DesignerGenerates task-adaptive topologies over fixed agent nodes, isolating topology design from capability composition. Skillas- signment variants Flat-skillde- signer Retrieves a global skill set for the whole team without assigning skills to individual agent slots. Embedding- only incidence Assigns skills using frozen embedding similarity, removing the learned incidence generator. Execution variant SIGMAw/o mailbox Keeps predicted skill assignments but flattens incoming messages into a shared agent context. Upper- bound diagnostic Oracleinci- dence Uses gold or pseudo-label incidence assignments at test time; included only as a diagnostic upper bound. A smaller∆indicates stronger robustness when the available skill library changes. When target incidence labels are available, we re- port micro-averaged precision, recall, and F1 over skill-agent assignments. LetT inc ,P inc , andG inc denote the true-positive, predicted-positive, and gold-positive incidence counts over all(q,m,k), respectively: Prec inc = T inc /P inc ,(37) Rec inc = T inc /G inc ,(38) F1 inc = 2/(Prec −1 inc + Rec −1 inc ).(39) When annotated communication graphs are available, we report edge precision, recall, and F1 over directed edges: Prec edge = |E q ∩ E ⋆ q | |E q | ,(40) Rec edge = |E q ∩ E ⋆ q | |E ⋆ q | ,(41) F1 edge = 2· Prec edge · Rec edge Prec edge + Rec edge .(42) 15 Table 5: Main hyperparameters used by SIGMA. SymbolMeaningSetting KNumber of agent slots5 TCommunication roundsMatched to benchmark budget τ skill Skill selection threshold0.25 k s Maximum skills per agent slot 3 RCandidate support size for pseudo-labeling 8 r s Routed skills per incoming message 2 γ e Edge prediction threshold0.5 bMailbox summary budgetFixed under total context budget λ e Edge loss weight1.0 λ c Compatibility weight1.0 λ g Graph sparsity weight1× 10 −3 For test-time skill insertion, we additionally re- port inserted-skill hit rate: Hit new = 1 |Q new | X q∈Q new I[h new (q)],(43) where h new (q) =∃m∈L new , k s.t. B q [m,k] = 1. (44) F Implementation Details F.1 Hyperparameters Table 5 lists the main hyperparameters used by SIGMA. Values that depend on a benchmark- specific execution budget are selected on the vali- dation split and then fixed for test evaluation. F.2 Training Configuration We summarize the core training configuration of SIGMA in Table 6, as well as the training dynamics of loss-related parameters in Figure 7. The inci- dence predictor and topology decoder are trained jointly with full-batch optimization. Unless other- wise specified, all source-library and unseen-library experiments use the same architecture, objective, and decoding thresholds. F.3 Training Objective The training objective combines incidence super- vision, optional edge reconstruction, and sparsity regularization. The incidence generator is trained Table 6: Core training configuration of SIGMA. ItemSetting Training targetJoint training of F θ and D φ,ψ OptimizerAdamW Epochs50 for MMLU experiments Learning rate1× 10 −3 Text encoderHashingTextEncoder Embedding dimension384 Hidden dimension of F θ 256 Hidden dimension of D φ,ψ 128 Number of agent slots K5 Top-r candidate skills8 Candidate support size8 Maximum skills per slot3 Edge label modechain Anchor modechain Acyclic graph constrainttrue Edge loss weight1.0 Graph sparsity weight1× 10 −3 Compatibility weight1.0 Anchor loss weight1.0 Random seed0 Incidence threshold0.25 Edge prediction threshold0.5 Temperature0.0 with binary cross-entropy over skill-agent assign- ments: L inc = X q M X m=1 K X k=1 BCE B ⋆ q [m,k],p m,k , (45) wherep m,k = σ(α m,k ). When annotated commu- nication graphs are available, the topology decoder is trained with L edge = X q X i̸=j BCE(A ⋆ q [i,j],σ(ℓ ij )).(46) If annotated target graphs are unavailable, this term is computed against the shared structural prior de- scribed in Appendix D.2 or omitted in the matched- decoder control. We further use a soft bundle-size cap and a graph sparsity penalty: L sparse = X q K X k=1 max 0, M X m=1 p m,k − k s ! + λ g X q X i̸=j σ(ℓ ij ). (47) The final objective is L =L inc + λ e L edge + λ s L sparse .(48) 16 Figure 7: Training dynamic of loss. The incidence term trains the skill-agent assign- ment predictor. The edge term is used only when annotated communication graphs or a shared struc- tural prior are available. The sparsity term prevents degenerate solutions in which every slot receives too many skills or the decoded communication graph becomes overly dense. F.4 Complexity LetMbe the number of skills andKthe number of agent slots. Incidence scoring requiresO(MK) skill-agent pair evaluations. The skill-bundle com- patibility term is not computed over allM 2 skill pairs. Instead, it is evaluated over sparse active supports. During inference, each agent has at most k s selected skills, so pairwise skill compatibility across agent pairs costsO(K 2 k 2 s ). Therefore, the active compatibility computation is controlled by the bundle-size budget rather than the full skill- library size. G Additional Results G.1 Robustness to Unfamiliar Skill Libraries Table 14 reports the full source-to-unseen library results across six benchmarks. SIGMA achieves the best unseen-library accuracy on every benchmark and shows the smallest performance drop in all cases. On average, SIGMA drops by only 0.95 points, compared with 2.99 forG-Designer, 4.06 for GPTSwarm, and 4.02 for LLM-Debate. This suggests that incidence-based skill assignment is less dependent on a fixed skill inventory and can more reliably compose newly introduced skill cards into effective agent slots. G.2 Detailed Token and Runtime Analysis To further quantify the computational cost of SIGMA, we report detailed token consumption and wall-clock runtime across six benchmarks and three base LLMs. As shown in Table 13, the overall cost varies across benchmarks, mainly depending on the number of evaluated questions and the diffi- culty of the task. GSM8K contributes the largest token usage for all three backbones due to its larger test set, while HumanEval and MMLU require sub- stantially fewer total tokens. Despite these dif- ferences, SIGMA remains practical across model scales: all benchmark evaluations finish within a few hours, and most individual benchmark runs complete within roughly one hour. Table 7: Skill sets used by each dataset. DatasetSkills MMLU final_synthesis, problem_decomposition, evidence_check, analogy, counterexample, elimination, concept_recall, constraint_tracking, causal_reasoning, uncertainty_calibration, calculation, domain_translation GSM8K synthesize, verify, retrieve, reason MultiArith synthesize, reason, retrieve, verify SVAMP synthesize, retrieve, reason, verify AQuA synthesize, retrieve, reason, verify HumanEval edge_cases, implementation, final_code_review, spec_parse, complexity_check H Prompt Templates H.1 Agent Execution Prompt During execution, each agent receives a two-part prompt consisting of a system message and a user message. As shown in Figure 8, the system mes- sage specifies the agent identity, its assigned skill cards, and the rule that only task-relevant skills should be used. The user message provides the current task, routed mailbox summaries from pre- decessor agents, and the required response format. This prompt design ensures that skill assignments are not only used for node construction, but are also exposed to the LLM as executable instructions during multi-agent interaction. Here is an example: Figure 9 17 AGENT EXECUTION PROMPT Message format. ["role" : "system", "content" : system_prompt, "role" : "user", "content" : user_prompt] system_prompt You are agentagent_idin a multi-agent sys- tem. Your capabilities are defined by the assigned skill cards:selected skill cards. Use only skills relevant to the current step. Read routed mailbox evidence carefully and incorporate use- ful constraints, tool outputs, retrieved facts, or unresolved issues. user_prompt task query mailboxes skill-specific mailbox summaries responseReturn: (1) intermediate reasoning or action; (2) message to downstream agents; (3) tool/API/retrieval request if needed. Figure 8: Prompt format used for agent execution. H.2 Baseline Prompt Templates For reproducibility, we report the concrete Vanilla and CoT prompt templates used for single-agent baselines.Each template uses the same two- message format as the agent execution prompt above. For a given dataset,system_promptis con- structed by concatenating the dataset-specific Sys- tem base with either the Vanilla suffix or the CoT suffix; theuser_promptcontains the benchmark in- stance. All methods use the same benchmark split, deterministic decoding withtemperature=0.0, and the same dataset-specific answer parser. BASELINE PROMPT TEMPLATE: MMLU Message format. ["role" : "system", "content" : system_prompt, "role" : "user", "content" : user_prompt] system_prompt System base I will ask you a multiple-choice question. There are 4 answer options enumerated as A, B, C, and D. Only one option is correct. Always select the best available option from A, B, C, and D, even if none seems perfect. Do not answer that none of the options is correct. Vanilla suffix Reply with only one letter: A, B, C, or D. Do not include any analysis. CoT suffix Reason step by step before choosing the answer. Use at most 5 short sentences. Do not write tables, exhaustive cases, or long derivations. Put your final answer on the last line exactly in this format: Final answer: X where X is one of A, B, C, or D. user_prompt task The task is: question-with-options BASELINE PROMPT TEMPLATE: AQUA Message format. ["role" : "system", "content" : system_prompt, "role" : "user", "content" : user_prompt] system_prompt System base I will ask you a multiple-choice math question. There are 5 answer options enumerated as A, B, C, D, and E. Only one option is correct. Always select the best available option from A, B, C, D, and E. Vanilla suffix Reply with only one letter: A, B, C, D, or E. Do not include any analysis. CoT suffix Reason step by step before choosing the answer. Use at most 5 short sentences. Do not write tables, exhaustive cases, or long derivations. Put your final answer on the last line exactly in this format: Final answer: X where X is one of A, B, C, D, or E. user_prompt task The task is: question-with-A-E-options BASELINE PROMPT TEMPLATE: GSM8K, MULTI- ARITH, AND SVAMP Message format. ["role" : "system", "content" : system_prompt, "role" : "user", "content" : user_prompt] 18 system_prompt GSM8K base I will ask you a grade-school math word problem. Solve the problem and provide the numeric answer without units. Always put your final answer on the last line exactly in this format: The answer is X where X is the numeric answer. M-Arith base I will ask you a multi-step arithmetic word problem. Solve the problem and provide the numeric answer without units. Always put your final answer on the last line exactly in this format: The answer is X where X is the numeric answer. SVAMP base I will ask you an arithmetic word problem. Solve the problem and provide the numeric answer without units. Always put your final answer on the last line exactly in this format: The answer is X where X is the numeric answer. Vanilla suffix Reply with only the final answer line. Do not include analysis. CoT suffix Reason step by step before giving the final answer. Keep the reasoning concise. user_prompt task The task is: math-word-problem BASELINE PROMPT TEMPLATE: HUMANEVAL Message format. ["role" : "system", "content" : system_prompt, "role" : "user", "content" : user_prompt] system_prompt System base You will be given a Python function signature and docstring. Write a correct, concise Python implementation. Do not change the function name, arguments, or expected return type. The final answer must include a complete Python code block with the full function definition. Vanilla suffix Reply with only one Python code block. Do not include analysis outside the code block. CoT suffix Reason briefly before writing the implementation. Keep the reasoning concise. Put the final implementation in the last Python code block. Do not write anything after the final code block. user_prompt task The task is: function spec ANSWER EXTRACTION USED WITH THE PROMPT TEMPLATES MMLU/AQuAThe parser first ignores any hidden reasoning before a closing </think> tag, then reads a leading standalone option letter, explicit final-answer markers such as Final answer: X, correct answer is X, and answer: X, or option-selection phrases such as choose option X. AQuA additionally supports matching emitted option text back to A–E. Numeric math The parser matches explicit answer markers including final answer, the answer is, answer is, answer, and #### . It also supports boxed answers. If no marker is found, it uses the last numeric expression and normalizes commas, currency symbols, percent signs, braces, fractions, decimals, and surrounding punctuation. HumanEvalWe report pass@1. The evaluator extracts the last valid Python code block containing a function or class definition and scores it once with the benchmark unit tests, with no retries, no execution-feedback loop, and no access to held-out tests during generation. I Additional Details I.1 Dataset description We evaluate SIGMA on six benchmarks covering general reasoning, mathematical reasoning, and code generation. MMLU is used to test broad multiple-choice reasoning ability, while GSM8K, MultiArith, SVAMP, and AQuA evaluate mathe- matical reasoning under both numerical-answer and multiple-choice formats. HumanEval is used to assess code generation ability with pass@1 as the evaluation metric. Table 8 summarizes the an- swer type, metric, test-set size, and license informa- tion for each benchmark. For MMLU, we follow the cost-controlled protocol of prior graph-based MAS designers, including G-Designer and ARG- Designer, and use the same fixed 153-question shuf- fled evaluation subset for all methods and base LLMs. This subset is fixed before method-specific tuning; optimization and pseudo-label construction use separate training/dev examples and do not ac- cess held-out answers. We use all existing benchmark artifacts only for their intended research evaluation purposes: MMLU for multiple-choice reasoning, GSM8K, MultiArith, SVAMP, and AQuA for mathemati- cal reasoning, and HumanEval for code-generation evaluation. We do not redistribute modified bench- mark data or use these artifacts outside research 19 Table 8: Dataset descriptions and statistics. CategoryDatasetTypeMetric#TestLic. GeneralMMLUMulti- choice Acc.153 MIT Math GSM8KNum.Acc.1,319 MIT M-ArithNum.Acc.600 – SVAMPNum.Acc.1,000 MIT AQuA Multi- choice Acc.254 Apache-2.0 CodeH-EvalCodePass@1164 MIT evaluation settings. I.2 Skill distribution Figure 10 and Table 7 show the normalized skill dis- tribution across different datasets. Overall, the skill distributions reveal clear task-dependent specializa- tion. To complement this distributional view, Ta- ble 10 reports the corresponding skill-library statis- tics, including the number of source and unseen skill cards, the cognitive/tool-API split, the aver- age number of skills assigned to each agent where available, and the source–unseen library overlap. Together, these results show not only which skills are frequently selected for each dataset, but also how the underlying skill libraries are constructed and controlled across source and unseen settings. I.3 Model Size and Computation Budget Table 11 reports the size of the base executors and the trainable components introduced by SIGMA. The base LLMs are used only as frozen executors during multi-agent inference, while SIGMA adds a lightweight controller consisting of the incidence predictorF θ and the topology decoderD φ,ψ . The controller has fewer than one million trainable pa- rameters in total, making the additional training cost small compared with the base LLM executors. For execution, we use three representative backbones with different serving configurations. Qwen3-8B and GPT-OSS-120B are served locally with vLLM, where Qwen3-8B disables the think- ing template and GPT-OSS-120B uses reasoning ef- fort. GPT-4o-mini is accessed through an OpenAI- compatible backend. All SIGMA controller training runs are conducted on4×NVIDIA RTX A6000 GPUs 48GB. I.4 OOD Diagnostic Analysis In the MMLU Split-A setting, ID examples contain observed skill-bundle patterns, whereas OOD ex- amples contain the held-out bundle elimination, evidence_check,final_synthesis, testing whether SIGMA generalizes to unseen skill com- positions within the same benchmark. In the skill- library transfer setting, ID uses the source skill library, while OOD replaces it with semantically different unseen skill cards at test time, testing whether the controller can transfer across changed capability resources. Table 12 reports ID/OOD accuracy, OOD perfor- mance change, and OOD retention. Across both diagnostics, SIGMA maintains strong OOD accu- racy and non-negative OOD change. These results suggest that its gains are not merely due to mem- orizing in-distribution skill assignments, but also to recomposing useful capabilities under shifted skill-composition and skill-library conditions. J Failure Analysis We further inspect representative failure cases of SIGMA to understand when skill-incidence based multi-agent design is less effective. Overall, the failures mainly come from five sources: overly sparse topology decoding, insufficient skill diver- sity, biased final aggregation, benchmark-specific answer priors, and imperfect mailbox routing. Overly sparse communication topology. A no- table failure mode is that the decoded communica- tion graph can become empty when the edge thresh- old is too strict or when the learned topology scores are overly sparse. In an over-sparse MMLU-153 di- agnostic variant, all 153 evaluated examples were decoded as zero-edge graphs, which effectively prevents agents from exchanging information. In this case, SIGMA degenerates into isolated skill- composed agents, losing the benefit of multi-agent collaboration. This suggests that topology sparsity should be regularized but not over-constrained. A practical fix is to calibrate the edge threshold on the validation split, enforce a minimum number of edges, or add a topology loss that discourages fully disconnected graphs. Correct minority lost during aggregation.In 9 out of 27 MMLU wrong cases, at least one agent produces the correct answer, but the final deci- sion still follows the wrong majority. This sug- gests that simple majority-style aggregation can suppress useful minority evidence. The issue is not necessarily that SIGMA fails to generate the right reasoning, but that the final decision mecha- nism does not sufficiently distinguish high-quality 20 Table 9: Controlled comparison between SINGLE-AGENT+SKILLS and SIGMA using GPT-OSS-120B. SINGLE- AGENT+SKILLS receives the same union of selected skill cards as SIGMA, but removes multi-agent execution, topology decoding, and mailbox routing. MethodMul.Topo.Comp.MailboxMMLUGSM8KMultiArithSVAMPAQuAHumanEvalAvg. CoT✗83.3984.8195.6395.1976.0290.8787.65 SINGLE-AGENT+SKILLS✗✓✗85.4187.6595.9396.7388.3793.2491.22 SIGMA✓87.2896.2598.3495.9490.1695.8393.97 Table 10: Skill-library statistics for the source and unseen skill libraries.M src andM unseen denote the number of skill cards in the source and unseen libraries. Cog. and Tool/API report the number of cognitive and tool/API skills in the source/unseen libraries. DatasetM src M unseen Cog. S/UTool/API S/UAvg. skills/agent S/UOverlapExamples: source→ unseen MMLU, half split666 / 60 / 02.80 / 2.880 concept_recall→ analogy; calculation→ uncertainty_calibration GSM8K121212 / 120 / 0– / –0 source_extract_numbers→ target_quantity_schema MultiArith121212 / 120 / 0– / –0 source_choose_operation→ target_operation_router SVAMP121212 / 120 / 0– / –0 source_unit_tracking→ target_answer_unit_check AQuA121212 / 120 / 0– / –0 source_consistency_check→ target_estimate_validate HumanEval121212 / 100 / 2– / 2.420 source_spec_parse→ target_contract_reader source_test_design→ target_local_test _designer evidence from repeated but weak agreement. A natural improvement is evidence-weighted aggre- gation, where final answers are weighted by skill relevance, confidence, mailbox evidence quality, or verifier judgments rather than raw vote count. Answer-option bias.We also observe that wrong predictions sometimes overuse particular answer options, especially A or D. This points to a possi- ble option-prior or prompt-order bias in multiple- choice tasks. Such bias may come from the base LLM, the answer-format constraint, or the distribu- tion of predecessor messages in the mailbox. To diagnose this issue, we recommend option-order ro- bustness tests, where the same question is evaluated under different permutations of answer choices. If predictions change substantially under permutation, the system should use option-normalized prompt- ing or answer re-mapping during evaluation. K Impact Statement Positive impact. This work studies skill- incidence graphs for compositional multi-agent system design.By constructing agents from task-conditioned skill bundles rather than fixed role descriptions, SIGMA may improve the modu- larity, reusability, and adaptability of multi-agent systems. Risks and mitigation. Flexible skill composi- tion may introduce risks when unsafe, irrelevant, or conflicting skills are assigned to agents, especially in tool-augmented, code-execution, or real-world decision-making settings. Incorrect skill routing can propagate errors across agents and make sys- tem behavior harder to audit. To mitigate these risks, SIGMA should be used with bounded skill libraries, explicit execution constraints, assignment logging, and human oversight in high-stakes appli- cations. Our experiments are limited to controlled benchmarks, and we do not recommend direct de- ployment in safety-critical domains without further validation and robustness evaluation. Figure 10: Skill distribution across datasets. 21 Table 11: Model and artifact sizes used by SIGMA. ComponentSizeRole Base LLM executors Qwen3-8B8B classLocal vLLM executor for the fixed MMLU-153 evaluation protocol. GPT-OSS-120B120B classExecutor for MMLU, GSM8K, MultiArith, SVAMP, AQuA, HumanEval, and ablations. GPT-4o-mini UndisclosedAuxiliary executor for additional benchmark artifacts. SIGMA trainable controller F θ incidence predictor 461,953 params Predicts the skill-agent incidence matrix B. D φ,ψ topology decoder 427,266 params Predicts the learned communication topology. Full SIGMA checkpoint ≈3.57 MBContains F θ + D φ,ψ , with 889,219 trainable parameters in total. Incidence-only checkpoint 164,997 params / 664 KB Early variant using only F θ without learned topology decoding. Table 12: OOD diagnostic results. ID denotes the in- distribution or source-library setting, while OOD de- notes the held-out or unseen-library setting.∆ OOD is computed as OOD accuracy minus ID accuracy, where higher values indicate better OOD retention. Diag.MethodIDOOD∆ OOD ↑Ret. ↑ MMLU Split-A Fixed-chain75.00 75.00 +0.00100.00 SIGMA82.5085.00+2.50103.03 Skill- Lib. G-Designer77.12 77.78 +0.65100.85 SIGMA77.1279.08+1.96102.54 Split details.MMLU Split-A uses elimination, evidence_check,final_synthesis as the held-out OOD bundle. Skill-Lib. evaluates source-to-unseen skill- card transfer at test time. AGENT EXECUTION PROMPT EXAMPLE Message format. ["role" : "system", "content" : system_prompt, "role" : "user", "content" : user_prompt] system_prompt skill bundle Evidence checking: verify that the answer follows from stated evidence. Inputs: query, messages; outputs: analysis, answer ; tools:none; tags:mmlu. profile state No accumulated interaction history before execution. format constraint The agent receives one question with four options A–D; exactly one option is correct. It must select the best available option, use other agents’ reasoning only as critical advice, reply in fewer than 100 words, and put only one letter on the first line. user_prompt taskWhat one of the following is not a key management skill in planning? Option A: Conceptual skills Option B: Analytical skills Option C: IT and computing skills Option D: Communication skills mailbox context Mailbox[evidence_check] receives routed evidence from SIGMA slot 0 with similarity score 0.032. The predecessor selects C and argues that conceptual, analytical, and communication skills are core managerial competencies in planning, while technical/IT skills are less central. expected output Return the answer letter and a concise evidence-based explanation. Figure 9: Example runtime prompt used by SIGMA. The system message injects the assigned skill card, profile state, and answer-format constraints, while the user mes- sage provides the concrete question and routed mailbox evidence. 22 Table 13: Token comparison across representative benchmarks and multi-agent methods. DatasetMethodPerf.Tokens / Runtime MMLU SIGMA87.28 1.18×10 5 / 18.0min CARD85.78 7.23×10 5 / 20.5min ARG-Designer 85.63 5.57×10 5 / 41.2min G-Designer85.06 5.25×10 5 / 67.9min GPTSwarm83.58 2.61×10 6 / 55.1min LLM-Debate82.92 1.54×10 6 / 75.4min HumanEval SIGMA95.83 4.24×10 5 / 30.9min CARD93.98 7.28×10 5 / 70.2min ARG-Designer 93.47 8.71×10 5 / 51.6min G-Designer92.88 7.05×10 5 / 50.8min GPTSwarm92.30 4.57×10 6 / 56.9min LLM-Debate91.43 6.90×10 6 / 68.6min GSM8K SIGMA96.25 5.48×10 6 / 84.1min CARD93.44 9.91×10 6 / 154.1min ARG-Designer 91.08 1.06×10 7 / 149.4min G-Designer88.62 8.09×10 6 / 201.3min GPTSwarm86.88 1.44×10 7 / 241.2min LLM-Debate85.53 2.63×10 7 / 267.7min AQuA SIGMA90.16 8.22×10 5 / 62.9min CARD82.76 1.76×10 6 / 72.9min ARG-Designer 78.62 1.09×10 6 / 67.7min G-Designer78.13 9.01×10 5 / 92.1min GPTSwarm77.41 2.07×10 6 / 109.2min LLM-Debate75.38 3.12×10 6 / 144.8min SVAMP SIGMA95.94 2.14×10 6 / 85.5min CARD95.48 8.01×10 6 / 117.5min ARG-Designer 94.81 7.17×10 6 / 104.8min G-Designer95.21 3.07×10 6 / 101.2min GPTSwarm94.77 2.97×10 7 / 101.3min LLM-Debate94.89 3.55×10 7 / 165.9min MultiArith SIGMA98.34 8.62×10 5 / 48.1min CARD98.21 2.38×10 6 / 64.2min ARG-Designer 98.67 1.14×10 6 / 78.7min G-Designer96.86 1.09×10 6 / 95.4min GPTSwarm96.50 2.00×10 6 / 125.5min LLM-Debate95.72 3.10×10 6 / 173.4min Table 14: Robustness to unfamiliar skill libraries across benchmarks using GPT-4o-mini as the base model.∆ denotes the performance drop from the source skill li- brary to unseen skill cards, with lower values indicating stronger generalization under library changes. Bench.MethodSource Lib.Unseen Lib.∆↓ MMLU LLM-Debate68.9663.735.23 GPTSwarm71.3764.846.53 G-Designer73.3270.053.27 CARD75.1173.681.43 SIGMA75.6875.030.65 GSM8K LLM-Debate87.3285.292.03 GPTSwarm87.8384.473.36 G-Designer89.2687.281.98 CARD93.2191.441.77 SIGMA92.9691.861.10 AQuA LLM-Debate72.8666.965.90 GPTSwarm74.6569.145.51 G-Designer76.6070.36.30 CARD80.4176.853.56 SIGMA83.6782.501.17 Human. LLM-Debate79.472.586.82 GPTSwarm81.2676.414.85 G-Designer82.4878.454.03 CARD85.0781.483.59 SIGMA88.7186.292.42 SVAMP LLM-Debate87.4385.461.97 GPTSwarm90.1288.141.98 G-Designer90.3289.171.15 CARD91.6590.790.86 SIGMA93.6493.430.21 Multi. LLM-Debate94.1191.962.15 GPTSwarm96.0793.932.14 G-Designer96.7595.501.25 CARD96.9495.950.99 SIGMA99.6499.460.18 23 L Case Study L.1 HumanEval: Communication-Linked Code Generation Qualitative Study Setting Evaluation Setting Method SIGMA-humaneval. Dataset / split HumanEval test. Base LLM gpt-4o-mini. Decision method FinalWriteCode. Run summary124 executed problems, 110 solved problems, 88.71% accuracy. Interpretation focusThis case illustrates how communication exposes edge cases and turns them into an executable final implementation. Learned Topology Node ids 5euR (slot 0), 5Rg5 (slot 1), 7b2z (slot 2), 7Tja (slot 3), 4mKN (slot 4). Spatial chain 5euR -> 5Rg5 -> 7b2z -> 7Tja -> 4mKN. Temporal edgesNone. Edge probabilities0→1 = 0.9987, 1→2 = 0.9981, 2→3 = 0.9982, 3→4 = 0.9986. Graph constraint anchor=chain; acyclic=true. Reading Guide ❶QueryFunction signature, docstring, examples, ground-truth implementation, and final prediction. ❷TraceSelected skill bundles, chain topology, execution order, and round-level message flow. ❸Agent cardsEach card summarizes one skill-composed node and its main contribution. ❹FinalThe FinalWriteCode decision node that writes the final Python solution. Case: Edge-case repair for iscube Query Function specification and expected behavior Record id: HumanEval/77.Solved: yes. Task: implement iscube(a), which returns True if integer a is a cube of some integer. Examples:iscube(1) -> True,iscube(2) -> False,iscube(-1) -> True,iscube(64) -> True, iscube(0) -> True, iscube(180) -> False. Ground-truth pattern: use the absolute value or signed cube-root handling, then check whether the rounded cube root cubed equals the original magnitude. Final prediction: a negative-aware cube-root check with root ** 3 == a. 24 Trace Skill-incidence and message flow Execution order: 5euR -> 5Rg5 -> 7b2z -> 7Tja -> 4mKN. Slot 0 skills: implementation, edge_cases, final_code_review. Slot 1 skills: edge_cases, final_code_review. Slot 2 skills: spec_parse, implementation, edge_cases. Slot 3 skills: implementation, edge_cases. Slot 4 skills: spec_parse, edge_cases, complexity_check. Interpretation: the learned chain routes the task from planning and algorithm description to code generation, testing feedback, and final bug fixing. 5euR: implementation + edge-case analysis + final review Role/profile state: SIGMA slot 0; no accumulated history before execution. Mailbox input: empty, because this is the first node in the chain. Main response: proposes a single-function design and suggests checking whether the rounded cube root cubed equals the input. Representative code pattern: return round(a ** (1/3)) ** 3 == a. Diagnosis: useful high-level implementation plan, but the initial pattern is incomplete for negative inputs and may be numerically fragile. 5Rg5: edge-case analysis + final review Mailbox input: receives the slot-0 design through the chain edge 5euR -> 5Rg5. Main response: restates the cube-root algorithm, documents expected usage, and emphasizes the equality check after rounding. Evidence contribution: preserves the concise algorithmic structure and keeps the implementation simple. Diagnosis: useful algorithmic clarification, but it still inherits the same cube-root risk from the initial design. 7b2z: specification parsing + implementation + edge-case analysis Mailbox input: receives the slot-1 algorithm description through 5Rg5 -> 7b2z. Main response: writes an executable implementation using round(a ** (1/3)). Internal-test signal: the generated implementation passes internal testing in the trace. Diagnosis: partially useful because it produces runnable code, but risky because the round-then-cube method can mishandle negative inputs or large integers. 7Tja: implementation + edge-case analysis Mailbox input: receives the slot-2 code through 7b2z -> 7Tja. Main response: warns that the implementation may fail due to floating-point rounding and highlights negative numbers and large integers as important edge cases. Concrete checks suggested:iscube(-8),iscube(-1), and large cube values such as729or 1000000000. Diagnosis: this is the key corrective signal: the edge-case skill identifies the hidden weakness of the earlier implementation. 25 4mKN: specification parsing + edge-case analysis + complexity check Mailbox input: receives the tester feedback through 7Tja -> 4mKN. Main response: revises the implementation to handle negative inputs by computing a signed cube- root candidate before checking root ** 3 == a. Complexity: constant-time arithmetic with no auxiliary data structures. Diagnosis: integrates the upstream warning into a bug-fixed implementation, showing how the final slot acts as a repair node rather than another independent generator. 4sMD: FinalWriteCode decision node System role: final code writer; must output the completed Python function. Final input pattern: task specification plus the chain-produced implementation and edge-case feedback. Final behavior: outputs a negative-aware implementation: ifa < 0, compute a signed cube-root candidate using -(-a) ** (1/3); otherwise use a ** (1/3); finally check root ** 3 == a. Final result: solved. Interpretation: the case shows a successful repair path. The early implementation nodes provide a simple candidate solution, the edge-case node exposes the negative-input risk, and the final writer incorporates that correction into the submitted code. Figure 11: A HumanEval case where SIGMA’s chain topology turns a simple but risky cube-root implementation into a negative-aware final solution. L.2 MMLU: Skill-Conditioned Evidence Aggregation Qualitative Study Setting Evaluation Setting Base LLM and split Qwen3-8B on the fixed MMLU-153 evaluation subset. Overall run153 executed questions, 94 solved questions, 61.44% accuracy. Execution regimeFiveAnalyzeAgentnodes produce skill-conditioned answers, followed by one FinalRefer decision node. Interpretation focusThese cases examine whether skill-composed agents provide complementary evidence and whether the final decision can repair or amplify noisy intermediate answers. Skill-conditioned Aggregation Regime Node representationEach case constructs U q ∈ R 5×384 from the selected skill bundles before graph decoding. Observed graph stateThe MMLU examples activate no pairwise spatial edge after thresholding, so the final decision node aggregates independently generated skill-conditioned evidence. What this shows The analysis isolates the benefit and limitation of skill composition and evidence aggregation, rather than attributing the MMLU examples to agent-to-agent message passing. 26 Reading Guide ❶QueryQuestion, options, record id, ground-truth answer, and final prediction. ❷TraceConcrete node ids, execution order, skill-incidence bundles, activated edges, and maximum decoded edge probability. ❸Agent cardsThe five executable columns selected by the skill-incidence matrix B q . Each card lists the node id, role, injected skill profile, mailbox state, and agent output. ❹FinalThe FinalRefer node. Its user prompt contains the task plus the five node outputs shown immediately above the final card; the final response is restricted to one letter. Case: Answer-label repair on MMLU Query Question and expected answer Record id: mmlu-test-miscellaneous-39.Solved: yes. Question: In the film The Talented Mr. Ripley, who plays Mr. Ripley? Options: A. Jude LawB. Matt DamonC. Dustin HoffmanD. Ben Affleck. Ground truth: B. Final prediction: B. Case focus: the compact answer prefixes are noisy, but the rationales mostly identify Matt Damon; the final decision node repairs the answer-label mismatch. Trace Topology and skill-incidence trace Nodes: mLV2 (slot 0), hj9X (slot 1), wxdu (slot 2), 3M9o (slot 3), d7XF (slot 4). Execution order: mLV2 -> hj9X -> wxdu -> 3M9o -> d7XF. Slot 0 skills: elimination, analogy, evidence_check. Slot 1 skills: evidence_check. Slot 2 skills: final_synthesis. Slot 3 skills: counterexample, final_synthesis. Slot 4 skills: counterexample. Activated edges:spatial_edges=[],temporal_edges=[]; maximum decoded edge probability = 3.16×10 −3 < 0.5. Interpretation: the case isolates skill-conditioned evidence aggregation rather than agent-to-agent message passing. mLV2: elimination + analogy + evidence check Role/profile state: SIGMA slot 0; no accumulated interaction history before execution. Injected skill profile: option elimination rules out implausible choices; analogy mapping connects the query to a known pattern; evidence checking verifies that the answer follows from stated evidence. Mailbox input: empty because no predecessor output arrived. Agent output: A. The rationale recalls that The Talented Mr. Ripley stars Matt Damon as the titular character, eliminates other options by filmography, and confirms Matt Damon as the correct answer. Diagnosis: useful evidence, but the leading answer prefix conflicts with the rationale and the option mapping. 27 hj9X: evidence check Role/profile state: SIGMA slot 1; no accumulated interaction history before execution. Injected skill profile: evidence checking verifies that the answer follows from stated evidence. Mailbox input: empty because no predecessor output arrived. Agent output: A. The rationale identifies the target role, recalls that Matt Damon portrayed Mr. Ripley in the 1999 film, and selects the answer based on this information. Diagnosis: useful evidence, again with a wrong leading letter. wxdu: final synthesis Role/profile state: SIGMA slot 2; no accumulated interaction history before execution. Injected skill profile: final synthesis combines partial arguments into a concise final answer. Mailbox input: empty because no predecessor output arrived. Agent output: A. The response identifies the film, recalls the actor who portrayed Mr. Ripley, but incorrectly states that Jude Law played the role. Diagnosis: wrong factual hypothesis; this is the main misleading card in the aggregation set. 3M9o: counterexample + final synthesis Role/profile state: SIGMA slot 3; no accumulated interaction history before execution. Injected skill profile: counterexample search looks for edge cases that falsify an answer; final synthesis combines partial arguments. Mailbox input: empty because no predecessor output arrived. Agent output: A. The rationale identifies Matt Damon as the actor who portrayed Mr. Ripley in The Talented Mr. Ripley. Diagnosis: useful corrective evidence despite the noisy answer prefix. d7XF: counterexample Role/profile state: SIGMA slot 4; no accumulated interaction history before execution. Injected skill profile: counterexample search looks for edge cases that falsify an answer. Mailbox input: empty because no predecessor output arrived. Agent output: A. The rationale states that Matt Damon portrayed the character in the 1999 film and explicitly ends with Answer: B. Diagnosis: explicitly exposes the mismatch between the noisy prefix A and the correct textual answer B. UmWw: FinalRefer decision node System role: top decision-maker; must output exactly one of A, B, C, or D. FinalRefer input: the prompt contains the task/options plus all five node outputs above:mLV2: A, hj9X: A, wxdu: A, 3M9o: A, and d7XF: A ... Answer: B. Final response: B. Final result: solved. Interpretation: the final node is not a raw majority vote over answer prefixes. It reads the rationales and repairs the answer-label noise because most cards point to Matt Damon and one card explicitly states Answer: B. Figure 12: A complete case where the ffnal decision node repairs answer-label noise by reading the agent rationales. 28 Case B: Counterexample agents correct a noisy majority Query Question and expected answer Record id: mmlu-test-abstract_algebra-167.Solved: yes. Question: Statement 1: If a finite group has ordernthen the group contains a subgroup of orderd for every positive divisor d of n. Statement 2: If a belongs to a finite group then|a| divides|G|. Options: A. True, TrueB. False, FalseC. True, FalseD. False, True. Ground truth: D. Final prediction: D. Case focus: three agents produce noisy compact prefixes A, but most rationales identify the correct false/true mapping; counterexample agents provide the decisive correction. Trace Topology and skill-incidence trace Nodes/execution order: mLV2 -> hj9X -> wxdu -> 3M9o -> d7XF. Slot 0 skills: elimination, analogy, evidence_check. Slot 1 skills: evidence_check. Slot 2 skills: final_synthesis. Slot 3 skills: counterexample, final_synthesis. Slot 4 skills: counterexample. Compact answers: A, A, A, D, D. Activated edges:spatial_edges=[],temporal_edges=[]; maximum decoded edge probability = 1.71×10 −3 < 0.5. Interpretation: the final decision follows the mathematical evidence rather than the noisy compact- answer majority. mLV2: elimination + analogy + evidence check Mailbox input: empty. Agent output: A. The rationale says Statement 1 is false because Lagrange’s theorem only states that subgroup orders divide the group order, not that every divisor appears as a subgroup order. It also says Statement 2 is true because the order of an element divides the group order. Diagnosis: the reasoning supports false/true, but maps this evidence to option A instead of D. hj9X: evidence check Mailbox input: empty. Agent output: A. The rationale identifies Statement 1 as false and Statement 2 as true, and explicitly notes that A is incorrect while D is the correct false/true option. Diagnosis: noisy prefix, but the rationale explicitly identifies D. wxdu: final synthesis Mailbox input: empty. Agent output: A. The response again states that Statement 1 is false and Statement 2 is true, then explains that the correct choice should be D. Diagnosis: another prefix/rationale mismatch with correct mathematical evidence. 29 3M9o: counterexample + final synthesis Mailbox input: empty. Agent output: D. Statement 1 is false because not all finite groups have subgroups for every divisor of their order; Statement 2 is true by Lagrange’s theorem. Diagnosis: clean counterexample-style correction that directly supports the ground-truth label. d7XF: counterexample Mailbox input: empty. Agent output: D. The response independently confirms the same false/true mapping: subgroup orders must divide the group order, but not every divisor must occur, while element order divides group order. Diagnosis: independently confirms the correction and reinforces the minority compact answer. UmWw: FinalRefer decision node System role: top decision-maker; must output exactly one of A, B, C, or D. FinalRefer input: task/options plus five node outputs: three compact prefixes A and two compact prefixes D, with most rationales supporting false/true. Final response: D. Final result: solved. Interpretation: the final node follows the consistent mathematical evidence rather than the noisy compact-answer majority, showing that skill cards are treated as evidence sources rather than plain role labels. Figure 13: A MMLU case where counterexample skills provide the decisive corrective signal and allow the final decision node to override a noisy compact-answer majority. Case C: Recoverable disagreement among skill-composed agents Query Question and expected answer Record id: mmlu-test-public_relations-3.Solved: yes. Question: Which of these organizations is most effective in engaging with customers online? Options: A. StarbucksB. Coca-ColaC. WholefoodsD. Redbull. Ground truth: A. Final prediction: A. Case focus: heterogeneous skill-composed agents surface both Starbucks-supporting evidence and a plausible Red Bull distractor, but the final decision selects the better-supported answer. 30 Trace Topology and skill-incidence trace Nodes/execution order: mLV2 -> hj9X -> wxdu -> 3M9o -> d7XF. Slot 0 skills: elimination, analogy, evidence_check. Slot 1 skills: evidence_check. Slot 2 skills: final_synthesis. Slot 3 skills: counterexample, final_synthesis. Slot 4 skills: counterexample. Compact answers: A, A, D, A, D. Activated edges:spatial_edges=[],temporal_edges=[]; maximum decoded edge probability = 1.96×10 −3 < 0.5. Interpretation: the aggregation remains stable despite disagreement because the final input contains enough grounded evidence for Starbucks. mLV2: elimination + analogy + evidence check Mailbox input: empty. Agent output: A. The response argues that Starbucks has a strong online presence, including a user-friendly website, mobile app, and social media engagement. Evidence contribution: supports Starbucks through integrated digital strategy and customer engage- ment. Diagnosis: useful Starbucks-supporting evidence. hj9X: evidence check Mailbox input: empty. Agent output: A. The rationale emphasizes Starbucks’ mobile app with rewards, active social media engagement, and integrated online customer experience. Evidence contribution: independently reinforces the same answer with additional customer- engagement evidence. Diagnosis: useful aligned evidence. wxdu: final synthesis Mailbox input: empty. Agent output: D. The response argues that Red Bull has a strong online presence, interactive content, and community engagement through platforms such as YouTube and social media. Evidence contribution: surfaces a plausible distractor. Diagnosis: useful for stress-testing the answer, but ultimately less supported than Starbucks. 3M9o: counterexample + final synthesis Mailbox input: empty. Agent output: A. The rationale argues that Starbucks excels through its mobile app, personalized offers, and social media interaction, while Coca-Cola and Red Bull also have strong digital presences. Evidence contribution: compares the distractors against Starbucks and supports the correct option. Diagnosis: useful synthesis that acknowledges alternatives without switching away from A. 31 d7XF: counterexample Mailbox input: empty. Agent output: D. The response favors Red Bull because of interactive content, community engage- ment, and digital innovation. Evidence contribution: makes the plausible Red Bull distractor visible. Diagnosis: noisy but informative disagreement. UmWw: FinalRefer decision node System role: top decision-maker; must output exactly one of A, B, C, or D. FinalRefer input: task/options plus five node outputs containing three Starbucks-supporting cards and two Red Bull distractor cards. Final response: A. Final result: solved. Interpretation: disagreement is recoverable because the final node receives enough grounded evidence for Starbucks while still seeing a plausible distractor. This is the desired behavior of skill diversity: disagreement is visible but not automatically decisive. Figure 14: A MMLU case where disagreement among skill-composed agents is recoverable because the final mailbox contains enough grounded evidence for the correct answer. Case D: Shared misconception in a domain-specific legal question Query Question and expected answer Record id: mmlu-test-international_law-1.Solved: no. Question: Who is an “injured State” in the law of international responsibility? Options: A. A State is “injured” in case that it has suffered a damage from the internationally wrongful conduct. B. A State is “injured” in cases that there has been a violation of a peremptory norm of international law. C. A State is “injured” should it acknowledge the existence of the internationally wrongful conduct. D. A State is “injured” if the obligation breached was owed to it individually or if it was owed to a group of States, including that State, and it was specially affected. Ground truth: D. Final prediction: A. Case focus: all agents share the same false legal premise, so aggregation has no corrective evidence to follow. 32 Trace Topology and skill-incidence trace Nodes/execution order: mLV2 -> hj9X -> wxdu -> 3M9o -> d7XF. Slot 0 skills: elimination, analogy, evidence_check. Slot 1 skills: evidence_check. Slot 2 skills: final_synthesis. Slot 3 skills: counterexample, final_synthesis. Slot 4 skills: problem_decomposition, final_synthesis. Compact answers: A, A, A, A, A. Activated edges:spatial_edges=[],temporal_edges=[]; maximum decoded edge probability = 1.70×10 −3 < 0.5. Interpretation: this failure reflects insufficient domain-specific evidence coverage rather than an answer-format issue. mLV2: elimination + analogy + evidence check Mailbox input: empty. Agent output: A. The rationale defines an injured State as one that has suffered damage from an internationally wrongful act and treats option A as directly correct. Diagnosis: shares the false premise that actual damage is the defining legal standard. hj9X: evidence check Mailbox input: empty. Agent output: A. The response repeats that an injured State is a State that suffered damage from wrongful conduct, rejecting the other options as related but incorrect. Diagnosis: aligned with the wrong premise; no corrective legal standard is introduced. wxdu: final synthesis Mailbox input: empty. Agent output: A. The response synthesizes the same definition and chooses A as the most direct description. Diagnosis: fluent synthesis amplifies the shared misconception. 3M9o: counterexample + final synthesis Mailbox input: empty. Agent output: A. The response argues that option A correctly defines the concept, while the other options misstate criteria or add unnecessary conditions. Diagnosis: the counterexample skill does not recover the missing Article-style legal condition. d7XF: problem decomposition + final synthesis Mailbox input: empty. Agent output: A. The response decomposes the definition, says option A captures damage from wrongful conduct, and rejects option D as overly complex. Diagnosis: additional decomposition changes the prompt shape but still fails to retrieve the correct legal criterion. 33 UmWw: FinalRefer decision node System role: top decision-maker; must output exactly one of A, B, C, or D. FinalRefer input: task/options plus five aligned but wrong A-supporting node outputs. Final response: A. Final result: not solved. Interpretation: this is a failure of evidence coverage. No card introduces the missing legal standard in option D, so the final node has no corrective signal to follow. Figure 15: A MMLU failure case where skill diversity does not help because every card shares the same false legal premise. Case E: Correct majority lost during final aggregation Query Question and expected answer Record id: mmlu-test-jurisprudence-37.Solved: no. Question: Which of the following criticisms of Llewellyn’s distinction between the grand and formal styles of legal reasoning is the most compelling? Options: A. There is no distinction between the two forms of legal reasoning. B. Judges are appointed to interpret the law, not to make it. C. It is misleading to pigeon-hole judges in this way. D. Judicial reasoning is always formal. Ground truth: C. Final prediction: A. Case focus: three agents correctly support C, but the final node overweights a salient minority counterexample and outputs A. Trace Topology and skill-incidence trace Nodes/execution order: mLV2 -> hj9X -> wxdu -> 3M9o -> d7XF. Slot 0 skills: elimination, analogy, evidence_check. Slot 1 skills: evidence_check. Slot 2 skills: final_synthesis. Slot 3 skills: counterexample, final_synthesis. Slot 4 skills: counterexample. Compact answers: C, C, C, A, D. Activated edges:spatial_edges=[],temporal_edges=[]; maximum decoded edge probability = 2.06×10 −3 < 0.5. Interpretation: this case exposes a final-aggregation limitation: correct majority evidence can be lost when a wrong minority rationale appears forceful. mLV2: elimination + analogy + evidence check Mailbox input: empty. Agent output: C. The rationale says option C criticizes the categorization of judicial reasoning as oversimplified, while A and D contradict each other and B is less relevant. Diagnosis: useful correct evidence. 34 hj9X: evidence check Mailbox input: empty. Agent output: C. The response argues that option C challenges the validity of pigeon-holing judges into reasoning styles, while B concerns judicial role rather than the distinction itself. Diagnosis: independently supports the correct option with aligned rationale. wxdu: final synthesis Mailbox input: empty. Agent output: C. The response selects C as the most nuanced and relevant criticism because it argues the categorization oversimplifies judges’ approaches. Diagnosis: third aligned correct card. 3M9o: counterexample + final synthesis Mailbox input: empty. Agent output: A. The response claims option A directly challenges the core of Llewellyn’s distinc- tion by denying its existence and treats this as the strongest counterexample. Diagnosis: salient but wrong minority rationale. d7XF: counterexample Mailbox input: empty. Agent output: D. The response argues that option D challenges the distinction by asserting that judicial reasoning is always formal. Diagnosis: another distractor card; it exposes an alternative challenge but does not match the best criticism. UmWw: FinalRefer decision node System role: top decision-maker; must output exactly one of A, B, C, or D. FinalRefer input: task/options plus five node outputs: three C-supporting cards, one A-supporting counterexample card, and one D-supporting counterexample card. Final response: A. Final result: not solved. Interpretation: this is an aggregation failure. The final node overweights a forceful but wrong minority counterexample and ignores that Agents 0–2 independently agree on C with aligned rationales. Figure 16: A MMLU failure case where three agents identify the correct answer, but the final decision node follows a minority distractor. 35