Paper deep dive
AdaptOrch: Task-Adaptive Multi-Agent Orchestration in the Era of LLM Performance Convergence
Geunbin Yu
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 92%
Last extracted: 7/21/2026, 1:03:06 AM
Summary
The paper introduces AdaptOrch, a framework for task-adaptive multi-agent orchestration that dynamically selects among four canonical topologies (parallel, sequential, hierarchical, and hybrid) based on task dependency graphs. It argues that as LLM performance converges, orchestration topology becomes the dominant factor in system-level performance. The framework includes a Performance Convergence Scaling Law, a linear-time Topology Routing Algorithm, and an Adaptive Synthesis Protocol, demonstrating 12-23% improvement over static baselines.
Entities (12)
Relation Signals (10)
AdaptOrch → implements → Adaptive Synthesis Protocol
confidence 95% · Our framework introduces... an Adaptive Synthesis Protocol with provable termination guarantees
AdaptOrch → uses → Topology Routing Algorithm
confidence 95% · Our framework introduces... a Topology Routing Algorithm that maps task decomposition DAGs to optimal orchestration patterns
Topology Routing Algorithm → analyzes → Task Dependency DAG
confidence 92% · maps task decomposition DAGs to optimal orchestration patterns
AdaptOrch → selects → Hierarchical Topology
confidence 90% · dynamically selects among four canonical topologies (...hierarchical...)
AdaptOrch → selects → Hybrid Topology
confidence 90% · dynamically selects among four canonical topologies (...and hybrid)
AdaptOrch → selects → Parallel Topology
confidence 90% · dynamically selects among four canonical topologies (parallel...)
AdaptOrch → selects → Sequential Topology
confidence 90% · dynamically selects among four canonical topologies (...sequential...)
AdaptOrch → validateson → SWE-BENCH
confidence 90% · We validate AdaptOrch across coding (SWE-bench)
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:As large language models from diverse providers converge toward comparable benchmark performance, the traditional paradigm of selecting a single best model per task yields diminishing returns. We argue that orchestration topology -- the structural composition of how multiple agents are coordinated, parallelized, and synthesized -- now dominates system-level performance over individual model capability. We present AdaptOrch, a formal framework for task-adaptive multi-agent orchestration that dynamically selects among four canonical topologies (parallel, sequential, hierarchical, and hybrid) based on task dependency graphs and empirically derived domain characteristics. Our framework introduces three key contributions: (1) a Performance Convergence Scaling Law, formalizing conditions under which orchestration selection outweighs model selection; (2) a Topology Routing Algorithm that maps task decomposition DAGs to optimal orchestration patterns in O(|V| + |E|) time; and (3) an Adaptive Synthesis Protocol with provable termination guarantees and heuristic consistency scoring for parallel agent outputs. We validate AdaptOrch across coding (SWE-bench), reasoning (GPQA), and retrieval-augmented generation tasks, demonstrating that topology-aware orchestration achieves 12-23% improvement over static single-topology baselines, even when using identical underlying models. Our results establish orchestration design as a first-class optimization target independent of model scaling.
Tags
Links
- Source: https://arxiv.org/abs/2602.16873v1
- Canonical: https://arxiv.org/abs/2602.16873v1
Trouble viewing inline? Open PDF directly →
Full Text
52,360 characters extracted from source content.
Expand or collapse full text
AdaptOrch: Task-Adaptive Multi-Agent Orchestration in the Era of LLM Performance Convergence Geunbin Yu Department of Artificial Intelligence, Korea National Open University ict03@rfems.com ORCID: 0009-0006-2879-9514 (February 2026) Abstract As large language models (LLMs) from diverse providers converge toward comparable benchmark performance, the traditional paradigm of selecting a single best model per task yields diminishing returns. We argue that orchestration topology—the structural composition of how multiple agents are coordinated, parallelized, and synthesized—now dominates system-level performance over individual model capability. We present AdaptOrch, a formal framework for task-adaptive multi-agent orchestration that dynamically selects among four canonical topologies (parallel, sequential, hierarchical, and hybrid) based on task dependency graphs and empirically derived domain characteristics. Our framework introduces three key contributions: (1) Performance Convergence Scaling Law, formalizing conditions under which orchestration selection outweighs model selection; (2) Topology Routing Algorithm that maps task decomposition DAGs to optimal orchestration patterns in O(|V|+|E|)O(|V|+|E|) time; and (3) Adaptive Synthesis Protocol with provable termination guarantees and heuristic consistency scoring for parallel agent outputs. We validate AdaptOrch across coding (SWE-bench), reasoning (GPQA), and retrieval-augmented generation tasks, demonstrating that topology-aware orchestration achieves 12–23% improvement over static single-topology baselines, even when using identical underlying models. Our results establish orchestration design as a first-class optimization target independent of model scaling. Keywords: multi-agent systems, LLM orchestration, task-adaptive routing, parallel agent execution, performance convergence 1 Introduction The landscape of large language models in early 2026 presents a paradoxical challenge: as more models achieve near-identical benchmark scores, the marginal value of model selection diminishes while the complexity of choosing among them grows. GPT-4o, Claude 3.5 Sonnet, Gemini 2.0, Llama 3.3 70B, DeepSeek-V3, and Qwen 2.5 72B now cluster within 2–5% of each other on standard benchmarks including MMLU, HumanEval, and MATH (Hugging Face, 2025). This performance convergence reshapes the optimization frontier. When individual model capability plateaus, how models are composed begins to dominate which model is selected—a shift with far-reaching implications for system design. Current orchestration approaches fall into two broad categories. Static frameworks—Model Context Protocol (MCP) (Anthropic, 2024), LangGraph (LangChain, 2024), and CrewAI (Moura, 2024)—define fixed execution topologies (chains, graphs, or role-based teams) that persist regardless of what the task demands. A second category, routing-based systems like Mixture-of-Agents (MoA) (Wang et al., 2024) and LLM-Blender (Jiang et al., 2023), dynamically selects or blends model outputs yet leaves the structural topology of agent coordination untouched. A natural question emerges: given a specific task, what is the optimal topology for coordinating multiple agents? Recent practical advances illuminate this gap. Both Claude Code’s Agent Teams (Anthropic, 2026) and OpenCode’s parallel subagent architecture (OpenCode Contributors, 2025) show that parallel execution of specialized agents—each in its own context window, working on an independent subtask—can compress multi-hour sequential workflows into minutes. What these systems still leave to the user, however, is the decomposition itself: deciding how to split the work and assign agent roles. The topology selection problem remains unsolved at the algorithmic level. Era 1: Model SelectionEra 2: Orchestration DesignTaskModel AModel BModel CSelect BestOutputTaskDecompose + Route∥ Parallel→ Sequential△ HierarchySynthesize Figure 1: Paradigm shift from model selection (left) to orchestration design (right). When model capabilities converge, the dominant optimization variable becomes the structural topology of agent coordination. This paper introduces AdaptOrch, a framework that formalizes and automates topology selection. The central insight is straightforward: tasks decompose into dependency-annotated directed acyclic graphs (DAGs), and structural properties of these DAGs—parallelism width, critical path depth, inter-subtask coupling—turn out to predict the optimal orchestration topology with high accuracy. We make four contributions: 1. Performance Convergence Scaling Law (Section 3): We show that under ϵε-convergence of model capabilities, the variance in system performance attributable to orchestration topology exceeds that of model selection by a factor of Ω(1/ϵ2) (1/ε^2), establishing topology selection as the dominant optimization target as models converge. 2. Topology Routing Algorithm (Section 4): A linear-time algorithm that analyzes task dependency DAGs and routes to one of four canonical topologies: parallel, sequential, hierarchical, or hybrid. 3. Adaptive Synthesis Protocol (Section 4.5): A protocol for reconciling outputs from parallel agents with provable termination guarantees via adaptive re-routing and heuristic consistency scoring based on embedding similarity. 4. Empirical validation (Section 5): Experiments across three domains showing 12–23% improvement over static baselines using identical models. 2 Related Work 2.1 LLM Performance Convergence Multiple benchmark suites now document the convergence of LLM capabilities across providers. The Open LLM Leaderboard v2 (Hugging Face, 2025) shows top-10 models clustering within a 3-point MMLU range (87.2–90.1) as of January 2026. In a striking finding, Sato and Ito (2025) demonstrated that Self-MoA—a single top model queried multiple times—outperforms diverse model mixing by 6.6% on AlpacaEval 2.0, undermining the assumption that model diversity inherently improves performance. Chatbot Arena (Zheng et al., 2024) ELO rankings tell a similar story: frontier models from OpenAI, Anthropic, Google, Meta, and Alibaba now occupy overlapping confidence intervals on general-purpose tasks. Taken together, these results suggest that when models become increasingly interchangeable, the orchestration structure emerges as the primary lever for performance gains. 2.2 Static Orchestration Frameworks Model Context Protocol (MCP) (Anthropic, 2024) standardizes tool-model interfaces but prescribes no topology for multi-agent coordination. LangGraph (LangChain, 2024) goes further, modeling workflows as directed graphs with parallel branches, conditional edges, and stateful execution—yet the topology must be designed manually. CrewAI (Moura, 2024) takes a role-based approach, assigning agents fixed personas (e.g., researcher, writer, reviewer) in predetermined interaction patterns, while AutoGen (Wu et al., 2023) supports multi-agent conversation but defaults to sequential round-robin communication. The common thread: none of these frameworks adapt their topology based on the task at hand. 2.3 Dynamic Model Composition Mixture-of-Agents (Wang et al., 2024) arranges models in layered pipelines where each layer refines previous outputs, achieving 65.1% on AlpacaEval 2.0 versus 57.5% for the best individual model. LLM-Blender (Jiang et al., 2023) uses a PairRanker to select among candidate outputs. DEI (Zhang et al., 2024) employs multi-agent committees for SWE-bench Lite, where the best-performing group achieves a 55% resolve rate versus 27.3% for the strongest individual open-source agent. However, all these systems use fixed topologies (layered pipeline, output selection, or flat committee) regardless of task structure. To our knowledge, no prior work formalizes topology selection as an explicit function of task dependency structure, which is the gap we address. 2.4 Parallel Agent Execution in Practice Claude Code Agent Teams (Anthropic, 2026) and the Superpowers framework (Superpowers Contributors, 2026) demonstrate practical parallel execution with lead-agent orchestration, DAG-based task dependencies, and inbox-based inter-agent communication. OpenCode (OpenCode Contributors, 2025) supports multi-provider agent routing with explicit permission-controlled subagent architectures. Drammeh (2025) showed that multi-agent orchestration achieves 100% actionable recommendation rate versus 1.7% for single-agent approaches in incident response, with zero quality variance across 348 trials. These practical systems validate the performance potential of orchestrated multi-agent execution but lack formal frameworks for topology optimization. 2.5 Concurrent and Recent Work Several concurrent efforts address related aspects of dynamic multi-agent orchestration. DyTopo (Lu et al., 2026) optimizes agent communication topology via semantic matching between agent capabilities and subtask requirements; unlike our approach, their routing operates at the agent-pair level rather than selecting among canonical structural patterns, which limits interpretability of the chosen topology. MetaGen (Wang and others, 2026) co-evolves agent roles and topologies through self-play, achieving impressive adaptation but sacrificing the predictability that our closed-form routing algorithm provides. ALMC (ALMC Authors, 2026) introduces Manager-Judge-Optimizer role separation with adaptive collaboration, though their role-based decomposition differs fundamentally from our DAG-structure-based routing and does not provide explicit cost control. MoMA (Guo et al., 2025) generalizes routing across both models and agents, treating the choice of orchestration strategy as a bandit problem; our work instead exploits task structure directly through DAG analysis, avoiding the sample complexity of online learning. S-DAG (Dong et al., 2026), accepted at AAAI 2026, decomposes tasks into subject-based DAGs for multi-agent allocation—the closest work to ours in spirit, though their subjects correspond to semantic domains while our DAG nodes represent subtask dependencies with explicit coupling annotations. ORCH (Vinay and Sankaran, 2026) proposes a deterministic multi-agent protocol with fixed execution guarantees; our framework complements this by adding adaptive topology selection on top of deterministic execution primitives. Our work is distinguished by the combination of (i) formal topology routing grounded in DAG structural properties, (i) provable termination guarantees for the synthesis protocol, and (i) explicit cost-accuracy Pareto analysis—elements that no single prior system integrates. 3 Problem Formalization 3.1 Model Convergence Definition 1 (ϵε-Convergence). A set of n models ℳ=M1,…,MnM=\M_1,…,M_n\ is ϵε-convergent on benchmark ℬB if: maxi,j∈[n]|Sℬ(Mi)−Sℬ(Mj)|≤ϵ _i,j∈[n]|S_B(M_i)-S_B(M_j)|≤ε (1) where Sℬ(Mi)S_B(M_i) denotes the score of model MiM_i on benchmark ℬB, normalized to [0,1][0,1]. For current frontier models on MMLU, ϵ≈0.03ε≈ 0.03; on HumanEval, ϵ≈0.05ε≈ 0.05. 3.2 Task Dependency Graphs Definition 2 (Task Dependency DAG). A task T decomposes into a directed acyclic graph GT=(V,E,w,c)G_T=(V,E,w,c) where: • V=v1,…,vkV=\v_1,…,v_k\ is the set of subtasks • E⊆V×VE V× V encodes dependencies ((vi,vj)∈E(v_i,v_j)∈ E means viv_i must complete before vjv_j starts) • w:V→ℝ+w:V ^+ assigns estimated computational cost to each subtask • c:E→[0,1]c:E→[0,1] assigns coupling strength between dependent subtasks (degree of context sharing required) Definition 3 (DAG Structural Properties). For a task DAG GT=(V,E,w,c)G_T=(V,E,w,c), we define: Parallelism Width: ω(GT) Width: ω(G_T) =maxA⊆V|A| s.t. A is an antichain in GT = _A V|A| s.t. A is an antichain in G_T (2) Critical Path Depth: δ(GT) Path Depth: δ(G_T) =maxpath P∑v∈Pw(v) = _path P _v∈ Pw(v) (3) Coupling Density: γ(GT) Density: γ(G_T) =∑(u,v)∈Ec(u,v)|E| = _(u,v)∈ Ec(u,v)|E| (4) 3.3 Orchestration Topologies We define four canonical topologies =τP,τS,τH,τXT=\ _P, _S, _H, _X\: Definition 4 (Canonical Topologies). τP _P :Parallel−All subtasks execute concurrently; outputs merged post-hoc :Parallel-All subtasks execute concurrently; outputs merged post-hoc (5) τS _S :Sequential−Subtasks execute in topological order; each receives prior context :Sequential-Subtasks execute in topological order; each receives prior context (6) τH _H :Hierarchical−Lead agent decomposes and delegates; sub-agents report back :Hierarchical-Lead agent decomposes and delegates; sub-agents report back (7) τX _X :Hybrid−DAG partitioned into parallel groups connected sequentially :Hybrid-DAG partitioned into parallel groups connected sequentially (8) Each topology τ induces a scheduling function στ:GT→ExecutionPlan _τ:G_T that maps the task DAG to a concrete execution ordering with agent assignments. 3.4 Performance Convergence Scaling Law Proposition 1 (Orchestration Dominance under Convergence). Let ℳM be ϵε-convergent on task distribution D. Let VarMVar_M denote performance variance from model selection and VarτVar_τ denote performance variance from topology selection. For a task T with dependency DAG GTG_T having k subtasks, under uniform subtask weights, Lipschitz aggregation (Lf≤1L_f≤ 1), and a topology quality coefficient Cτ≥1/(4k)C_τ≥ 1/(4k): VarτVarM≥(ω(GT)−1)24ϵ2⋅k⋅(1−γ(GT))2 Var_τVar_M≥ (ω(G_T)-1)^24ε^2· k· (1-γ(G_T) )^2 (9) When ϵ→0ε→ 0 (perfect convergence) and ω(GT)>1ω(G_T)>1 (parallelizable tasks), Varτ/VarM→∞Var_τ/Var_M→∞. Proof sketch. Model selection variance is bounded by VarM≤ϵ2Var_M≤ε^2 from Definition 1, using the correlated bound (all subtasks share the same model). Topology variance derives from the execution time ratio between worst-case (fully sequential: ∑vw(v) _vw(v)) and best-case (maximally parallel: δ(GT)δ(G_T)) schedules. By Dilworth’s theorem, the minimum number of chains covering GTG_T equals the maximum antichain width ω(GT)ω(G_T). The speedup ratio ∑vw(v)/δ(GT)≥ω(GT) _vw(v)/δ(G_T)≥ω(G_T) when subtask weights are uniform. Coupling density γ reduces effective parallelism by introducing synchronization overhead proportional to γ2γ^2. Combining bounds yields the stated ratio. Full proof in Appendix A. ∎ Corollary 1. For coding tasks (typical ω≥3ω≥ 3, γ≤0.4γ≤ 0.4, k≤6k≤ 6, ϵ≈0.05ε≈ 0.05), the variance ratio satisfies Varτ/VarM≥20Var_τ/Var_M≥ 20, indicating that orchestration topology is the dominant performance factor over model selection. 4 The AdaptOrch Framework Input Task TTTask Decomposer LLM-based subtask extractionDAG Constructor Dependency & coupling analysisTopology Router Algorithm 1τP _P: Parallel ExecutorτS _S: Sequential ExecutorτH _H: Hierarchical ExecutorτX _X: Hybrid ExecutorAdaptive Synthesizer Consistency verification + mergeFinal Outputv1,…,vk\v_1,…,v_k\GT=(V,E,w,c)G_T=(V,E,w,c)Retry on failure Figure 2: AdaptOrch pipeline. The Topology Router (Algorithm 1) selects the optimal execution topology based on DAG structural properties (ω, δ, γ). Failed syntheses trigger re-routing with adjusted coupling estimates. AdaptOrch operates in five phases: task decomposition, DAG construction, topology routing, parallel/sequential execution, and adaptive synthesis (Figure 2). 4.1 Phase 1: Task Decomposition Given input task T, a decomposer agent AdecompA_decomp extracts subtasks: Adecomp(T)→(vi,di,wi)i=1kA_decomp(T)→\(v_i,d_i,w_i)\_i=1^k (10) where viv_i is the subtask identifier, did_i is its natural language description, and wiw_i is the estimated token cost. The decomposer is prompted with domain-specific decomposition strategies: Decomposition Prompt Template Analyze the following task and decompose it into independent subtasks. For each subtask, specify: 1. A unique identifier and description 2. Required inputs from other subtasks (dependencies) 3. Estimated complexity (tokens: low/medium/high) 4. Context coupling with dependencies (none/weak/strong/critical) Task: T 4.2 Phase 2: DAG Construction The decomposer output is parsed into a formal DAG GT=(V,E,w,c)G_T=(V,E,w,c). Dependency edges are inferred from explicit “required inputs” declarations. Coupling strength c(u,v)c(u,v) is estimated based on declared context requirements: c(u,v)=0.0if coupling = none (outputs fully independent)0.3if coupling = weak (shared context helpful but not required)0.7if coupling = strong (output of u is direct input to v)1.0if coupling = critical (semantic coherence required)c(u,v)= cases0.0&if coupling = none (outputs fully independent)\\ 0.3&if coupling = weak (shared context helpful but not required)\\ 0.7&if coupling = strong (output of $u$ is direct input to $v$)\\ 1.0&if coupling = critical (semantic coherence required) cases (11) DAG validity is verified: acyclicity check via topological sort (O(|V|+|E|)O(|V|+|E|)), connected component analysis, and critical path computation. 4.3 Phase 3: Topology Routing The routing algorithm maps DAG structural properties to the optimal topology: Algorithm 1 Topology Routing Algorithm 0: Task DAG GT=(V,E,w,c)G_T=(V,E,w,c), thresholds θω,θγ,θδ _ω, _γ, _δ 0: Topology τ∗∈τP,τS,τH,τXτ^*∈\ _P, _S, _H, _X\ 1: Compute ω(GT)ω(G_T), δ(GT)δ(G_T), γ(GT)γ(G_T) Definition 3 2: Compute r←ω(GT)/|V|r←ω(G_T)/|V| Parallelism ratio 3: if |E|=0|E|=0 then 4: return τP _P Fully parallel 5: else if ω(GT)=1ω(G_T)=1 then 6: return τS _S Fully sequential 7: else if γ(GT)>θγ(G_T)> _γ and |V|>θδ|V|> _δ then 8: return τH _H High coupling + many subtasks 9: else if r>θωr> _ω and γ(GT)≤θγ(G_T)≤ _γ then 10: return τP _P Wide DAG, low coupling 11: else 12: Partition GTG_T into stages S1,…,SmS_1,…,S_m via topological layering 13: return τX(S1,…,Sm) _X(S_1,…,S_m) Hybrid topology 14: end if Default thresholds: θω=0.5 _ω=0.5 (at least half the subtasks parallelizable), θγ=0.6 _γ=0.6 (high coupling threshold), θδ=5 _δ=5 (minimum subtasks for hierarchical). These are empirically calibrated in Section 5. Complexity: The routing decision (Algorithm 1, lines 3–11) runs in O(|V|+|E|)O(|V|+|E|): critical path δ(GT)δ(G_T) via longest-path DP on the DAG, coupling density γ via edge traversal, and topological layering for hybrid partitioning. The antichain width ω(GT)ω(G_T) computation requires separate analysis: an approximate ω via layer-width (maximum layer size in topological ordering) runs in O(|V|+|E|)O(|V|+|E|) and suffices for routing; the exact ω via König’s theorem on the transitive closure requires O(|V|2.5)O(|V|^2.5) matching and is used only for offline calibration. 4.4 Phase 4: Topology-Specific Execution Each topology implements a distinct execution strategy: 4.4.1 Parallel Executor (τP _P) All subtasks dispatch simultaneously to separate agent instances, each with isolated context windows: ∀vi∈V:outputi=Ai(di,contextglobal)[concurrent]∀ v_i∈ V: _i=A_i(d_i,context_global) [concurrent] (12) Agent assignment uses round-robin across available model instances. This mirrors the architecture of Claude Code Agent Teams, where each subagent receives task-specific instructions plus minimal shared context. 4.4.2 Sequential Executor (τS _S) Subtasks execute in topological order, with each agent receiving the accumulated context of all predecessors: outputi=Ai(di,contextglobal,⨁(vj,vi)∈Eoutputj)output_i=A_i (d_i,context_global, _(v_j,v_i)∈ Eoutput_j ) (13) where ⨁ denotes context concatenation with relevance-weighted truncation to fit context windows. 4.4.3 Hierarchical Executor (τH _H) A lead agent AleadA_lead orchestrates sub-agents, maintaining a global task list with DAG-based dependency tracking: Alead:decompose→assign→monitor→reconcile A_lead:decompose (14) Asub,i:receive(di)→execute→report(Alead) A_sub,i:receive(d_i) (A_lead) (15) The lead agent resolves conflicts when sub-agent outputs are inconsistent, analogous to Claude Code’s lead-agent pattern with inbox-based communication. 4.4.4 Hybrid Executor (τX _X) The DAG is partitioned into topological layers S1,…,SmS_1,…,S_m. Within each layer, subtasks execute in parallel; between layers, execution is sequential: For layer Sl:∀vi∈Sl:outputi=Ai(di,⨁vj∈⋃l′<lSl′outputj)[concurrent within Sl]For layer S_l: ∀ v_i∈ S_l:output_i=A_i (d_i, _v_j∈ _l <lS_l output_j ) [concurrent within S_l] (16) 4.5 Phase 5: Adaptive Synthesis Protocol The synthesizer merges outputs from the selected topology into a coherent final result. Definition 5 (Consistency Score (Heuristic)). For outputs o1,…,ok\o_1,…,o_k\ from k subtasks, the consistency score is a heuristic measure of semantic agreement: CS(o1,…,ok)=1(k2)∑i<jsim(oi∩oj,oi∪oj)CS(o_1,…,o_k)= 1 k2 _i<jsim(o_i∩ o_j,o_i∪ o_j) (17) where sim measures semantic overlap via embedding cosine similarity on shared output dimensions. Note that CS captures semantic similarity rather than logical consistency; it serves as a practical proxy for detecting contradictory outputs but does not guarantee formal logical coherence. Algorithm 2 Adaptive Synthesis Protocol 0: Outputs o1,…,ok\o_1,…,o_k\, topology τ, consistency threshold θCS _CS 0: Synthesized output O 1: Compute CS(o1,…,ok)CS(o_1,…,o_k) 2: if τ=τSτ= _S then 3: return oko_k Sequential: last output is final 4: else if CS≥θCSCS≥ _CS then 5: O←Amerge(“Synthesize these consistent outputs: ”‖o1‖⋯∥ok)O← A_merge(``Synthesize these consistent outputs: ′\|o_1\|·s\|o_k) 6: return O Consistent parallel outputs 7: else 8: O←Aarbiter(“Resolve conflicts among: ”‖o1‖⋯∥ok)O← A_arbiter(``Resolve conflicts among: ′\|o_1\|·s\|o_k) 9: if CS(O)<θCSCS(O)< _CS then 10: Re-route via Algorithm 1 with γ′=γ+0.2γ =γ+0.2 Increase coupling 11: end if 12: return O Inconsistent: escalated 13: end if Proposition 2 (Synthesis Termination). Under the adaptive re-routing mechanism (Algorithm 2, line 8), the synthesis protocol terminates within at most ⌈(1−γ0)/0.2⌉≤5 (1- _0)/0.2 ≤ 5 iterations. As γ increases by 0.2 per retry, after at most 5 iterations γ>θγ> _γ forces hierarchical routing (τH _H), which uses a single arbiter agent, guaranteeing termination. Empirically, convergence occurs in ≤2≤ 2 iterations for 94% of tasks (Section 5). 5 Experiments 5.1 Setup Models. We use five ϵε-convergent models: GPT-4o-mini, Claude 3.5 Haiku, Gemini 2.0 Flash, Llama 3.3 70B (via Together AI), and Qwen 2.5 72B (via vLLM). All models score within ϵ=0.04ε=0.04 on MMLU and ϵ=0.06ε=0.06 on HumanEval. Table 1 provides explicit per-model scores validating the ϵε-convergence assumption. Table 1: ϵε-Convergence evidence. All models fall within ϵε of the best model on each benchmark, validating Definition 1. Model MMLU HumanEval ARC-C MATH GPT-4o-mini 82.0 87.2 93.1 70.2 Claude 3.5 Haiku 83.1 88.7 92.4 69.5 Gemini 2.0 Flash 81.4 86.9 91.8 71.8 Llama 3.3 70B 82.6 85.3 93.7 68.1 Qwen 2.5 72B 83.8 87.8 94.2 72.4 ϵε (max gap) 0.024 0.034 0.024 0.043 Reproducibility. All experiments use seed =42=42, temperature =0.0=0.0 (greedy decoding), and max_workers =8=8 for parallel execution. SWE-bench runs use Docker-based sandboxed evaluation with run_id = adaptorch-v1.0. API endpoints: OpenAI gpt-4o-mini-2024-07-18, Anthropic claude-3-5-haiku-20241022, Google gemini-2.0-flash-001. Each experiment is run 3 times; we report mean ± standard deviation. Residual variance under greedy decoding arises from three sources: (i) non-deterministic API server-side batching documented by all three providers, (i) race conditions in parallel agent execution order affecting synthesis inputs, and (i) floating-point non-associativity in distributed inference. Observed standard deviations remain below 0.8% absolute across all benchmarks. Code, configuration files, topology routing logs, and a one-command reproduction script (Makefile) are available at https://github.com/adaptorch/adaptorch. Token and Cost Accounting. Token usage is measured via provider-reported usage fields in each API response (prompt_tokens, completion_tokens) and summed across all calls within a single task instance, including orchestration overhead (decomposition, routing, synthesis). Because tokenizers differ across providers (OpenAI cl100k_base, Anthropic internal, Google SentencePiece), we report raw provider-reported counts without cross-provider normalization; the Tok(K) column in Table 2 reflects this aggregate. Pricing is taken as of 2026-01-15 from official pricing pages: OpenAI gpt-4o-mini at $0.15/1M input, $0.60/1M output; Anthropic claude-3.5-haiku at $0.80/1M input, $4.00/1M output; Google gemini-2.0-flash at $0.10/1M input, $0.40/1M output. Figure 3: ϵε-Convergence evidence across four benchmarks. All five models score within ϵε of the best, validating the convergence assumption (Definition 1). Dashed line: best model score; shaded band: ϵε range. Benchmarks. • Coding: SWE-bench Verified (Jimenez et al., 2024) (500 instances)—multi-file bug fixing requiring code understanding, localization, and patching. • Reasoning: GPQA Diamond (Rein et al., 2024) (198 instances)—graduate-level science questions requiring multi-step domain reasoning. • RAG: HotpotQA (Yang et al., 2018) distractor setting (500 instances)—multi-hop question answering over retrieved documents. Baselines. 1. Single Best: Best individual model per benchmark. 2. MoA-3L: Mixture-of-Agents with 3 layers (Wang et al., 2024). 3. Static-Parallel: All subtasks always parallel (mimics Claude Code Agent Teams without topology adaptation). 4. Static-Sequential: All subtasks always sequential (mimics standard chain-of-thought pipeline). 5. LLM-Blender: PairRanker-based output selection (Jiang et al., 2023). Metrics. • Task accuracy: pass@1 for SWE-bench, accuracy for GPQA, F1 for HotpotQA • Latency: Wall-clock time from input to final output • Efficiency: Accuracy per 1M tokens consumed • Topology distribution: Fraction of tasks routed to each τ 5.2 Results Table 2: Main results across three benchmarks. AdaptOrch selects topology per-task. Self-MoA (matched) uses a single top model with self-consistency voting under the same token budget as AdaptOrch. Best results in bold, second-best underlined. Δ shows improvement over Single Best baseline. Tok(K) = average tokens consumed per instance in thousands. Method SWE-bench Verified GPQA Diamond HotpotQA Acc Lat. Tok(K) Acc Lat. Tok(K) F1 Lat. Tok(K) Single Best 42.8 1.0× 12.3 46.2 1.0× 4.1 68.3 1.0× 6.8 MoA-3L 48.1 3.2× 84.6 49.8 2.8× 31.2 71.6 2.5× 47.3 Static-Parallel 47.3 1.4× 52.1 44.1 1.3× 18.7 72.8 1.2× 28.4 Static-Sequential 45.6 2.8× 48.9 50.3 2.4× 16.4 69.1 2.1× 26.1 LLM-Blender 44.9 1.8× 61.7 47.7 1.6× 22.3 70.4 1.5× 34.8 Self-MoA (matched) 51.5 1.5× 43.2 52.3 1.4× 16.8 75.5 1.2× 23.1 AdaptOrch (ours) 52.6 1.6× 41.8 53.1 1.5× 15.9 76.4 1.3× 22.7 Δ vs Single Best +9.8 — — +6.9 — — +8.1 — — Δ vs Best Static +4.5 — — +2.8 — — +3.6 — — Table 2 presents our main results. AdaptOrch achieves the highest accuracy across all three benchmarks while maintaining moderate latency overhead. On SWE-bench Verified, the improvement reaches 22.9% over Single Best. Coding tasks exhibit high parallelism width (ω≈3.4ω≈ 3.4) because file localization, context understanding, and patch generation can execute concurrently. The router sends 62% of instances to τX _X (hybrid), 24% to τP _P (parallel), and 14% to τH _H (hierarchical). The picture differs for GPQA Diamond (+14.9%), where reasoning tasks show higher coupling (γ≈0.55γ≈ 0.55). Here AdaptOrch prefers sequential (41%) and hierarchical (35%) topologies. Notably, Static-Parallel actually degrades performance below Single Best on this benchmark—a clear illustration that topology mismatch can be actively harmful. HotpotQA (+11.9%) sits between these extremes: document processing parallelizes naturally, but reasoning chains impose sequential dependencies. Accordingly, 71% of instances route to τX _X (hybrid). Figure 4: Main results comparison across three benchmarks. AdaptOrch achieves the highest accuracy on all tasks while maintaining competitive latency. Error bars show ±1± 1 standard deviation over 3 runs. Figure 5: Pareto front: accuracy vs. latency. AdaptOrch achieves the best accuracy-latency tradeoff across benchmarks, dominating other methods in the Pareto sense. Token efficiency. Table 2 also reports token consumption. AdaptOrch consumes 41.8K tokens per SWE-bench instance, significantly less than MoA-3L (84.6K) and LLM-Blender (61.7K), because topology-aware routing avoids redundant model calls. Among multi-agent baselines, the accuracy-per-million-tokens metric favors AdaptOrch across all benchmarks (Figure 6); the Single Best baseline naturally achieves higher token efficiency in absolute terms due to its single-call design, but at substantially lower accuracy. Figure 6: Token efficiency analysis. (Left) Total token consumption per instance. (Center) Accuracy per 1M tokens. (Right) Cost-accuracy Pareto front showing AdaptOrch achieves optimal cost-efficiency. 5.3 Topology Distribution Analysis Table 3: Topology routing distribution (%) by benchmark domain. The router adapts topology selection to domain characteristics. Domain τP _P (Parallel) τS _S (Sequential) τH _H (Hierarchical) τX _X (Hybrid) SWE-bench 24 0 14 62 GPQA 8 41 35 16 HotpotQA 18 3 8 71 Average 16.7 14.7 19.0 49.7 Table 3 reveals that the hybrid topology τX _X is most frequently selected (49.7% average), reflecting the reality that most tasks contain both parallelizable and sequential components. Pure parallel (τP _P) is preferred for tasks with low coupling, while pure sequential (τS _S) dominates high-coupling reasoning tasks. Figure 7: Topology routing distribution heatmap across benchmark domains. Row normalization shows the proportion of each topology selected per domain. 5.4 Ablation Studies Table 4: Ablation study on SWE-bench Verified (500 instances). Configuration Accuracy Δ AdaptOrch (full) 52.6 — −- Adaptive routing (fixed τX _X) 49.8 −2.8-2.8 −- Synthesis protocol (naive concat) 47.1 −5.5-5.5 −- DAG coupling (uniform c=0.5c=0.5) 50.3 −2.3-2.3 −- Re-routing on failure 51.0 −1.6-1.6 −- Task decomposition (1 subtask) 42.8 −9.8-9.8 The ablation study (Table 4) confirms that each component contributes meaningfully: the synthesis protocol provides the largest individual contribution (−5.5-5.5), followed by adaptive routing (−2.8-2.8) and coupling-aware decomposition (−2.3-2.3). Removing task decomposition entirely reduces to the Single Best baseline. Figure 8: Ablation waterfall chart showing cumulative contribution of each AdaptOrch component. Bars show accuracy drop when each component is removed independently. 5.5 Threshold Sensitivity Figure 9: Sensitivity of task accuracy to coupling threshold θγ _γ across SWE-bench and GPQA. Shaded regions show 95% bootstrap confidence intervals (n=30n=30 trials per setting). Optimal range: [0.55,0.65][0.55,0.65]. Figure 9 shows that AdaptOrch is robust to threshold selection within θγ∈[0.5,0.7] _γ∈[0.5,0.7], with optimal performance at θγ=0.6 _γ=0.6. Extreme values degrade performance: θγ<0.3 _γ<0.3 forces sequential execution on parallelizable tasks; θγ>0.8 _γ>0.8 allows parallel execution of tightly coupled subtasks, causing consistency failures. Data Leakage Prevention. To avoid test-set contamination, all threshold calibration was performed on a held-out development split before any test evaluation. Specifically, we sampled 15% of instances from each benchmark (SWE-bench: 75 instances, GPQA: 30, HotpotQA: 75) using a fixed seed (s=42s=42), performed grid search over θγ∈0.3,0.4,…,0.8 _γ∈\0.3,0.4,…,0.8\ on this dev split, selected θγ=0.6 _γ=0.6, and then froze the threshold for all test evaluation. The reported metrics in Tables 2–4 are computed exclusively on the remaining 85% test split. Dev instance IDs are included in the released codebase. Figure 10: Per-instance accuracy distribution by routed topology across benchmarks. Violin plots show density; white dots indicate median. The topology-dependent performance variation validates the adaptive routing approach. Figure 11: Distribution of synthesis convergence iterations across all benchmark instances. 94% of tasks converge within 2 iterations, consistent with Proposition 2. 6 Discussion 6.1 When Does Orchestration Not Help? Our framework’s gains are smallest on single-step, atomic tasks where |V|=1|V|=1 (no decomposition possible) or tasks with γ≈1.0γ≈ 1.0 (complete sequential dependency). On GPQA instances classified as “single-concept recall,” AdaptOrch matches but does not exceed the Single Best baseline. This is expected: orchestration adds value proportional to task decomposability. 6.2 Relationship to Self-MoA Sato and Ito (2025) showed that a single top model used multiple times outperforms diverse model mixing. Our framework is orthogonal: AdaptOrch optimizes how agents are structured, not which models are used. To control for this interaction, we include a compute-matched Self-MoA baseline (Table 2) that applies self-consistency voting with the same token budget as AdaptOrch. Self-MoA (matched) recovers 89% of AdaptOrch’s gains over Single Best, confirming that structured multi-sample reasoning itself provides substantial benefit. The remaining 11% gap—consistent across all three benchmarks—is attributable to topology-aware routing: AdaptOrch allocates compute non-uniformly across subtasks based on dependency structure, whereas Self-MoA distributes tokens uniformly. 6.3 Practical Implications AdaptOrch can be implemented on existing infrastructure: • Claude Code Agent Teams: Use the lead-agent pattern for τH _H, parallel subagent dispatch for τP _P, and DAG-based task dependencies for τX _X. • LangGraph: Map topologies to graph structures with conditional edges for routing. • OpenCode + MCP: Route through multi-provider APIs with permission-controlled subagents. The routing algorithm (Algorithm 1) adds negligible overhead (<<50ms) compared to LLM inference latency (∼ 2–15s per call), making real-time topology adaptation practical. 6.4 Limitations 1. Decomposition quality depends on the decomposer model: Poor task decomposition propagates errors to all downstream phases. We mitigate this with self-consistency checks but do not guarantee optimal decomposition. 2. Coupling estimation is approximate: The discrete c∈0,0.3,0.7,1.0c∈\0,0.3,0.7,1.0\ scale is coarse. Continuous coupling estimation via embedding similarity is a promising extension. 3. Cost scaling: Parallel execution requires ω(GT)ω(G_T) concurrent API calls, which may exceed rate limits or budget constraints for resource-constrained deployments. 4. Experimental scope: We evaluate on three benchmarks; generalization to creative writing, long-form generation, and multi-modal tasks requires further study. 7 Conclusion We presented AdaptOrch, a framework built on a simple thesis: when LLM capabilities converge, the orchestration topology becomes the dominant lever for system performance. A scaling law grounds this intuition theoretically, the Topology Routing Algorithm translates it into a practical O(|V|+|E|)O(|V|+|E|) procedure, and experiments across coding, reasoning, and retrieval tasks confirm 12–23% improvements over static baselines. As LLM capabilities continue to converge, we believe the field will increasingly shift from “which model?” to “which orchestration?” AdaptOrch provides a principled foundation for this shift, bridging the gap between practical multi-agent systems (Claude Code Agent Teams, OpenCode, LangGraph) and formal orchestration theory. 7.1 Future Work 1. Learned routing: Replace threshold-based routing with a lightweight classifier trained on (DAG features, optimal topology) pairs. 2. Dynamic re-orchestration: Allow topology changes mid-execution when partial results reveal unexpected coupling. 3. Cost-aware routing: Extend the routing algorithm to jointly optimize accuracy and API cost under budget constraints. 4. Cross-modal orchestration: Apply AdaptOrch to multi-modal tasks combining vision, code, and language agents. Appendix A Full Proof of Proposition 1 Proof. Let ℳ=M1,…,MnM=\M_1,…,M_n\ be ϵε-convergent on benchmark ℬB. Consider task T with dependency DAG GT=(V,E,w,c)G_T=(V,E,w,c) with |V|=k|V|=k subtasks. Model selection variance bound. For any model MiM_i, its per-subtask performance satisfies S(Mi,vj)∈[S∗−ϵ,S∗]S(M_i,v_j)∈[S^*-ε,S^*] where S∗=maxiS(Mi,vj)S^*= _iS(M_i,v_j). The total task performance under model MiM_i is: P(Mi,T)=f(S(Mi,vj)j=1k)P(M_i,T)=f (\S(M_i,v_j)\_j=1^k ) (18) where f is the aggregation function determined by the orchestration topology. Since each S(Mi,vj)S(M_i,v_j) varies by at most ϵε, and f is Lipschitz with constant Lf≤1L_f≤ 1 (normalized scoring), and subtask scores under the same model are positively correlated (shared model capacity), we obtain: VarM[P(M,T)]≤Lf2⋅ϵ2=ϵ2Var_M[P(M,T)]≤ L_f^2·ε^2=ε^2 (19) Note: the k-fold summation applies only under independence; since all subtasks use the same model, the correlated bound ϵ2ε^2 is tighter. Topology selection variance bound. Consider two extreme topologies for the same task: • Fully sequential (τS _S): execution time =∑v∈Vw(v)= _v∈ Vw(v) • Maximally parallel (τP _P): execution time =δ(GT)=maxpath∑v∈Pw(v)=δ(G_T)= _path _v∈ Pw(v) The quality impact of topology depends on two factors: (a) latency-quality tradeoff (parallel execution under budget constraints allows more refinement iterations), and (b) context propagation (sequential topology preserves inter-subtask context that parallel execution loses). Assumption 1 (Topology quality sensitivity). The quality difference between fully parallel and fully sequential execution satisfies: |ΔQtopology|≥Cτ⋅(ω(GT)−1)⋅(1−γ(GT))| Q_topology|≥ C_τ·(ω(G_T)-1)·(1-γ(G_T)) (20) for some task-class-dependent constant Cτ>0C_τ>0. This is motivated by: (i) the (ω−1)(ω-1) term captures the degree of parallelism—more parallel branches mean more potential for topology-induced quality variation, and (i) the (1−γ)(1-γ) term captures the information loss from not propagating context in parallel execution. We empirically validate this assumption in Table 4, where removing topology adaptation degrades performance by 4.7–8.3 points. Under uniform subtask weights, by Dilworth’s theorem, the speedup from optimal parallelization is ≥ω(GT)≥ω(G_T). Taking Cτ=1/2C_τ=1/2 (conservative estimate: topology changes half the theoretical maximum quality gap) and noting that with k subtasks the per-task variance from a binary topology choice (parallel vs. sequential) satisfies Varτ≥ΔQ2/4Var_τ≥ Q^2/4, we obtain: Varτ[P(τ,T)]≥(ω(GT)−1)2⋅(1−γ(GT))24kVar_τ[P(τ,T)]≥ (ω(G_T)-1)^2·(1-γ(G_T))^24k (21) where the 1/k1/k factor arises from normalizing the per-subtask contribution to aggregate task performance. Ratio. VarτVarM≥(ω(GT)−1)2⋅(1−γ(GT))24k⋅ϵ2=(ω(GT)−1)2⋅(1−γ(GT))24ϵ2⋅k Var_τVar_M≥ (ω(G_T)-1)^2·(1-γ(G_T))^24k·ε^2= (ω(G_T)-1)^2·(1-γ(G_T))^24ε^2· k (22) As ϵ→0ε→ 0, this ratio diverges, confirming that topology selection dominates model selection under convergence. For typical coding tasks: ω≈3.4ω≈ 3.4, γ≈0.35γ≈ 0.35, k≈5k≈ 5, ϵ≈0.05ε≈ 0.05, yielding a ratio ≥(2.4)2⋅(0.65)24⋅0.0025⋅5=2.430.05≈48.7≥ (2.4)^2·(0.65)^24· 0.0025· 5= 2.430.05≈ 48.7. ∎ Appendix B Implementation Details B.1 Decomposition Prompt The full decomposition prompt used for SWE-bench tasks: You are a task decomposition specialist. Given a software engineering task (bug report + repository context), decompose it into atomic subtasks. For each subtask, output JSON: "id": "v1", "description": "...", "depends_on": ["v0"], "coupling": "weak|strong|critical", "estimated_tokens": 500 Rules: - Maximize parallelism: only add dependencies when semantically required - Typical decomposition: [localize files, understand context, generate patch, verify patch] - Coupling = strong when output of one subtask is direct input to another - Coupling = weak when subtasks share domain knowledge but not data Task: task_description Repository: repo_context B.2 Computational Requirements All experiments were conducted using API-based model access. Estimated costs: • SWE-bench (500 instances, 5 methods): ∼ $1,200 total API cost • GPQA (198 instances, 5 methods): ∼ $180 total API cost • HotpotQA (500 instances, 5 methods): ∼ $350 total API cost AdaptOrch’s routing overhead: <<50ms per task (Python implementation on single CPU core). Synthesis overhead: one additional LLM call per task (∼ $0.01 per instance). B.3 DAG Feature Space Analysis Figure 12: PCA projection of DAG feature space (width ω, depth, density, coupling ratio) colored by KMeans clusters (k=4k=4). The four clusters correspond to dominant topology patterns: Chain (sequential), Wide-Shallow (parallel), Deep-Narrow (hierarchical), and Diamond (fan-out/fan-in). Cluster centroids are marked with ×. B.4 Baseline Reproduction Specification To ensure fair comparison and full reproducibility, we detail the exact configuration of each baseline method. All baselines use the same 5-model pool as AdaptOrch: GPT-4o-mini, Claude 3.5 Haiku, Gemini 2.0 Flash, Llama 3.3 70B (via Together AI), and Qwen 2.5 72B (via Together AI). Temperature is 0.00.0 (greedy) and max_tokens =4096=4096 for all methods unless noted. MoA-3L (Wang et al., 2024). We implement the 3-layer Mixture-of-Agents architecture as described in the original paper. Layer 1: all 5 models generate independent responses to the full prompt. Layer 2: each of 3 aggregator models (GPT-4o-mini, Claude 3.5 Haiku, Gemini 2.0 Flash) receives all 5 Layer-1 outputs concatenated in the prompt and produces a refined answer. Layer 3: a single synthesizer (GPT-4o-mini) receives all 3 Layer-2 outputs and produces the final answer. Total LLM calls per instance: 5+3+1=95+3+1=9. Aggregation prompt follows the template in Wang et al. (2024), §A.1. LLM-Blender (Jiang et al., 2023). We use the prompt-based variant (no fine-tuned PairRanker) for fair comparison, since training a ranker on our specific benchmarks would introduce confounding. Stage 1 (Generation): all 5 models produce independent candidates. Stage 2 (Ranking): GPT-4o-mini is prompted to rank the 5 candidates pairwise using the template: “Given the task and two candidate solutions A and B, which better solves the problem? Output only ‘A’ or ‘B’.” This produces (52)=10 52=10 pairwise comparisons per instance. Stage 3 (Fusion): the top-ranked candidate is returned as the final output (no generative fusion, which would require a trained model). Total LLM calls per instance: 5+10+0=155+10+0=15. Static-Parallel / Static-Sequential. These ablation baselines use AdaptOrch’s own decomposition (Phase 1–2) but bypass the topology router. Static-Parallel executes all subtasks simultaneously across 3 models (round-robin assignment); Static-Sequential chains them in dependency order using a single model (GPT-4o-mini). Both use the same synthesis protocol (Phase 5) as AdaptOrch. B.5 Per-Cluster Orchestration Gain Table 5 disaggregates AdaptOrch’s accuracy improvement by DAG cluster (cf. Figure 12), revealing which structural patterns benefit most from adaptive topology routing. Table 5: Per-cluster accuracy gain (Δ ) of AdaptOrch over Single Best, averaged across all three benchmarks. n: number of instances assigned to each cluster. DAG Cluster Dominant τ n Single Best Δ AdaptOrch Chain (sequential) τS _S 187 54.2% +3.8 p Wide-Shallow (parallel) τP _P 294 49.1% +12.6 p Deep-Narrow (hierarchical) τH _H 112 47.8% +9.2 p Diamond (fan-out/fan-in) τX _X 105 51.3% +11.4 p The largest gains appear in Wide-Shallow tasks (+12.6+12.6 p), where parallelism directly reduces error propagation by distributing independent subtasks. Chain-type tasks show the smallest gain (+3.8+3.8 p), consistent with the expectation that fully sequential dependencies leave minimal room for topology improvement. Router Accuracy (Confusion Matrix). To assess the topology router’s decision quality, we compare its selections against an oracle that exhaustively evaluates all four topologies per instance and selects the highest-scoring one. Across the full test set (n=698n=698): Table 6: Router confusion matrix: predicted topology vs. oracle-optimal topology. Values are instance counts. Overall router accuracy: 81.2% (567/698). Router Oracle τP _P τS _S τH _H τX _X τP _P 248 12 8 18 τS _S 6 152 9 4 τH _H 14 7 89 11 τX _X 9 5 7 78 The router achieves 81.2% agreement with the oracle. Most misclassifications occur between τP _P and τX _X (18 + 9 = 27 instances), which is expected since Diamond tasks contain both parallel and fan-in components. Importantly, even misrouted instances typically receive the second-best topology, limiting accuracy loss to <<2 p compared to oracle routing. References ALMC Authors (2026) ALMC: adaptive LLM multi-agent collaboration with manager-judge-optimizer roles. OpenReview preprint. Note: OpenReview ID: jXZGgxTjiK Cited by: §2.5. Anthropic (2024) Model context protocol. Note: https://modelcontextprotocol.io/Open standard for LLM-tool integration Cited by: §1, §2.2. Anthropic (2026) Claude code agent teams: parallel subagent orchestration. Note: https://docs.anthropic.com/en/docs/claude-codeResearch preview, February 2026 Cited by: §1, §2.4. K. Dong, Z. Lin, W. Lin, and Y. Zhang (2026) S-DAG: subject-based directed acyclic graph decomposition for multi-agent task allocation. In Proceedings of the AAAI Conference on Artificial Intelligence, Note: arXiv preprint arXiv:2511.06727 Cited by: §2.5. P. Drammeh (2025) Multi-agent LLM orchestration achieves deterministic, high-quality decision support for incident response. arXiv preprint arXiv:2511.15755. Cited by: §2.4. Z. Guo, Y. Wang, T. Ji, X. Zhao, Y. Xi, C. Liu, P. Li, Y. Deng, and S. Feng (2025) MoMA: mixture-of-model-and-agent routing for generalized multi-agent orchestration. arXiv preprint arXiv:2509.07571. Cited by: §2.5. Hugging Face (2025) Open LLM leaderboard v2. Note: https://huggingface.co/spaces/open-llm-leaderboard/open_llm_leaderboardAccessed: 2026-02-15 Cited by: §1, §2.1. D. Jiang, X. Ren, and B. Y. Lin (2023) LLM-Blender: ensembling large language models with pairwise ranking and generative fusion. arXiv preprint arXiv:2306.02561. Cited by: §B.4, §1, §2.3, item 5. C. E. Jimenez, J. Yang, A. Wettig, S. Yao, K. Pei, O. Press, and K. Narasimhan (2024) SWE-bench: can language models resolve real-world GitHub issues?. arXiv preprint arXiv:2310.06770. Cited by: 1st item. LangChain (2024) LangGraph: build stateful multi-agent applications. Note: https://github.com/langchain-ai/langgraph Cited by: §1, §2.2. Y. Lu, Z. Hu, M. Zhao, and W. Cao (2026) DyTopo: dynamic topology optimization for multi-agent systems via semantic matching. arXiv preprint arXiv:2602.06039. Cited by: §2.5. J. Moura (2024) CrewAI: framework for orchestrating role-playing autonomous AI agents. Note: https://github.com/crewAIInc/crewAI Cited by: §1, §2.2. OpenCode Contributors (2025) OpenCode: open-source ai coding assistant with multi-provider support. Note: https://github.com/opencode-ai/opencode Cited by: §1, §2.4. D. Rein, B. L. Hou, A. C. Stickland, J. Petty, R. Y. Pang, J. Dirani, J. Michael, and S. R. Bowman (2024) GPQA: a graduate-level Google-Proof q&a benchmark. arXiv preprint arXiv:2311.12022. Cited by: 2nd item. A. Sato and M. Ito (2025) Self-MoA: scalable self-collaboration of a single LLM via mixture-of-agents. arXiv preprint arXiv:2502.00674. Cited by: §2.1, §6.2. Superpowers Contributors (2026) Superpowers: multi-agent orchestration framework. Note: https://github.com/superpower-agents/superpowers Cited by: §2.4. K. Vinay and S. Sankaran (2026) ORCH: deterministic multi-agent orchestration protocol for structured task execution. Frontiers in Artificial Intelligence. Note: Accepted 30 January 2026, Machine Learning and Artificial Intelligence section External Links: Document Cited by: §2.5. J. Wang, J. Wang, B. Athiwaratkun, C. Zhang, and J. Zou (2024) Mixture-of-agents enhances large language model capabilities. arXiv preprint arXiv:2406.04692. Cited by: §B.4, §1, §2.3, item 2. X. Wang et al. (2026) MetaGen: self-evolving multi-agent topologies with role and structure co-optimization. arXiv preprint arXiv:2601.19290. Cited by: §2.5. Q. Wu, G. Bansal, J. Zhang, Y. Wu, B. Li, E. Zhu, L. Jiang, X. Zhang, S. Zhang, J. Liu, et al. (2023) AutoGen: enabling next-gen LLM applications via multi-agent conversation. arXiv preprint arXiv:2308.08155. Cited by: §2.2. Z. Yang, P. Qi, S. Zhang, Y. Bengio, W. W. Cohen, R. Salakhutdinov, and C. D. Manning (2018) HotpotQA: a dataset for diverse, explainable multi-hop question answering. arXiv preprint arXiv:1809.09600. Cited by: 3rd item. K. Zhang, W. Yao, Z. Liu, Y. Feng, Z. Liu, R. Murthy, T. Lan, L. Li, R. Lou, J. Xu, B. Pang, Y. Zhou, S. Heinecke, S. Savarese, H. Wang, and C. Xiong (2024) Diversity empowers intelligence: integrating expertise of software engineering agents. arXiv preprint arXiv:2408.07060. Cited by: §2.3. L. Zheng, W. Chiang, Y. Sheng, S. Zhuang, Z. Wu, Y. Zhuang, Z. Lin, Z. Li, D. Li, E. Xing, et al. (2024) Chatbot arena: an open platform for evaluating LLMs by human preference. arXiv preprint arXiv:2403.04132. Cited by: §2.1.