Paper deep dive
DHCG: Dynamic Construction of Hierarchical Collaboration Graphs for LLM-Based Multi-Agent Reasoning
Jie Ren, Jiakang Yuan, Chenyu Huang, Hezeer Ma, Jiayuan Fan, Tao Chen
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 91%
Last extracted: 10/13/2026, 4:43:09 AM
Summary
The paper introduces DHCG, a framework for LLM-based multi-agent systems that dynamically constructs hierarchical collaboration graphs during inference. It formulates MAS design as a Partially Observable Markov Decision Process (POMDP), where a Planner dynamically generates roles, establishes dependencies, and decides when to finalize the graph based on execution feedback. The framework employs action-aware preference optimization for training and achieves state-of-the-art performance across code generation, mathematical reasoning, and domain-specific benchmarks.
Entities (10)
Relation Signals (9)
DHCG → usesmodule → Planner
confidence 95% · DHCG consists of a Planner, Workers, and a Generator.
DHCG → usesmodule → Worker
confidence 95% · DHCG consists of a Planner, Workers, and a Generator.
DHCG → usesmodule → Generator
confidence 95% · DHCG consists of a Planner, Workers, and a Generator.
DHCG → trainedwith → Action-aware Preference Optimization
confidence 92% · We further introduce action-aware preference optimization to train the Planner
DHCG → evaluatedon → MATH-500
confidence 90% · We systematically evaluate DHCG across code generation, mathematical reasoning, and domain-specific reasoning benchmarks.
DHCG → evaluatedon → GPQA
confidence 90% · We systematically evaluate DHCG across code generation, mathematical reasoning, and domain-specific reasoning benchmarks.
DHCG → formulatesas → POMDP
confidence 90% · we reframe MAS design as a partially observable Markov decision process
DHCG → outperforms → AutoGen
confidence 85% · DHCG achieves state-of-the-art average performance... outperforming both static and dynamic MAS baselines
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:LLM-based multi-agent systems (MAS) have demonstrated strong capabilities in solving complex problems across diverse domains. Recently, the dynamic orchestration of agent systems has become an important research direction. However, existing methods suffer from limited composition, misaligned dependencies, and inflexible scale, restricting their ability to adapt to reasoning requirements during execution. To address these limitations, we reframe MAS design as a partially observable Markov decision process, in which both the composition and scale of the MAS are dynamically determined. We propose DHCG, a novel framework that coordinates three modules (Planner, Worker, and Generator) to progressively construct a dynamic hierarchical collaboration graph from scratch based on the query and evolving execution feedback. At each step, guided by feedback, the Planner generates a set of distinct and complementary roles tailored to the current reasoning needs and selectively routes relevant information to each role. It can also finalize the hierarchical collaboration graph early or progressively expand it when additional reasoning is required. We further introduce action-aware preference optimization to train the Planner to make more effective decisions when constructing hierarchical collaboration graphs. We systematically evaluate DHCG across code generation, mathematical reasoning, and domain-specific reasoning benchmarks. DHCG achieves state-of-the-art average performance among the compared methods, improving over the single-agent baseline by 13.06 points and outperforming both static and dynamic MAS baselines by 2.77-8.02 points. Additional experiments further demonstrate its generalization across different Planner backbones and unseen Worker models.
Tags
Links
- Source: https://arxiv.org/abs/2610.07835v1
- Canonical: https://arxiv.org/abs/2610.07835v1
Trouble viewing inline? Open PDF directly →
Full Text
49,472 characters extracted from source content.
Expand or collapse full text
DHCG: Dynamic Construction of Hierarchical Collaboration Graphs for LLM-Based Multi-Agent Reasoning Jie Ren Jiakang Yuan Chenyu Huang Hezeer Ma Jiayuan Fan Tao Chen †thanks: Corresponding Author Abstract LLM-based multi-agent systems (MAS) have demonstrated strong capabilities in solving complex problems across diverse domains. Recently, the dynamic orchestration of agent systems has become an important research direction. However, existing methods suffer from limited composition, misaligned dependencies, and inflexible scale, restricting their ability to adapt to reasoning requirements during execution. To address these limitations, we reframe MAS design as a partially observable Markov decision process, in which both the composition and scale of the MAS are dynamically determined. We propose DHCG, a novel framework that coordinates three modules (Planner, Worker, and Generator) to progressively construct a dynamic hierarchical collaboration graph from scratch based on the query and evolving execution feedback. At each step, guided by feedback, the Planner generates a set of distinct and complementary roles tailored to the current reasoning needs and selectively routes relevant information to each role. It can also finalize the hierarchical collaboration graph early or progressively expand it when additional reasoning is required. We further introduce action-aware preference optimization to train the Planner to make more effective decisions when constructing hierarchical collaboration graphs. We systematically evaluate DHCG across code generation, mathematical reasoning, and domain-specific reasoning benchmarks. DHCG achieves state-of-the-art average performance among the compared methods, improving over the single-agent baseline by 13.06 points and outperforming both static and dynamic MAS baselines by 2.77–8.02 points. Additional experiments further demonstrate its generalization across different Planner backbones and unseen Worker models. 1College of Future Information Technology, Fudan University, Shanghai, China 2Shanghai Innovation Institute, Shanghai, China 1 Introduction Agents powered by large language models (LLMs) have demonstrated strong capabilities across a wide range of tasks, including code generation, decision making, and question answering (Yao et al. 2023; Shinn et al. 2023; Zhang et al. 2024; Schick et al. 2023). Despite these advances, a single agent may still face challenges when solving complex problems involving diverse expertise and verification from multiple perspectives. Recent studies have increasingly explored LLM-based multi-agent systems (MAS) (Wu et al. 2024; Team et al. 2025; Li et al. 2023), where multiple agents collaborate through role specialization and communication. Early frameworks such as AutoGen (Wu et al. 2024), CAMEL (Li et al. 2023), and MetaGPT (Hong et al. 2024) largely rely on manually designed roles and interaction patterns, requiring considerable human effort and providing limited task-specific adaptability. These limitations have motivated growing efforts to automatically design and adapt multi-agent collaboration for different tasks. Figure 1: Comparison of three MAS construction paradigms: (a) graph-based MAS; (b) workflow-based MAS; and (c) our feedback-driven graph construction paradigm. Existing approaches to automated MAS design can be broadly categorized into two paradigms: graph-based MAS and workflow-based MAS, as shown in Fig. 1(a) and Fig. 1(b). Graph-based MAS optimize inter-agent communication topologies through graph optimization, pruning, or topology generation (Zhuge et al. 2024; Zhang et al. 2025b; Li et al. 2026). A representative example is G-Designer (Zhang et al. 2025c), which employs graph neural networks to generate a task-adaptive communication topology. In parallel, workflow-based MAS construct and optimize executable workflows by organizing components through search, evolution, or feedback-driven refinement (Hu et al. 2025; Hu et al. 2026; Wang et al. 2025a). For example, AFlow (Zhang et al. 2025d) uses Monte Carlo tree search to iteratively optimize workflows. Despite their task-adaptive designs, existing dynamic MAS methods still suffer from several limitations. 1) Limited Composition. Existing methods construct MAS from predefined agent nodes or workflow operators. Consequently, they may provide insufficient role coverage because the agent composition cannot adapt to task-specific requirements or emerging reasoning needs during execution. 2) Misaligned Dependencies. Communication dependencies are often determined by predefined templates or global optimization objectives, rather than the actual information needs of downstream agents. Agents may receive irrelevant or redundant context while missing critical intermediate evidence, which can weaken collaboration and propagate errors through the reasoning process. 3) Inflexible scale. Fixed interaction rounds and one-shot workflow generation determine the reasoning scale before execution. This can cause the system to continue reasoning after sufficient evidence has been obtained, or stop before the remaining reasoning needs have been adequately addressed. Given the above limitations, a natural question arises: Can we dynamically design MAS at inference time, adapting their components, dependencies, and scale to the evolving reasoning state? To seek the answer to the above question, we draw inspiration from how real-world teams incrementally recruit experts according to evolving task needs, rather than assembling all members in advance. This motivates a feedback-driven dynamic collaboration graph construction paradigm for MAS design, as shown in Fig. 1(c). Unlike existing paradigms that determine agent components, communication structures, and interaction scales before execution, our paradigm constructs the MAS progressively from scratch using real-time execution feedback. At each construction step, unresolved reasoning needs are identified, and an appropriate number of complementary roles are generated, enabling task- and state-specific capability composition. Dependencies are then established according to each new role’s information requirements, aligning communication with downstream needs. Finally, the construction process adaptively determines whether to expand the collaboration graph or finalize the reasoning process, allowing the system scale to evolve with the current reasoning state. Together, these mechanisms help alleviate the limitations in role composition, dependency alignment, and system scalability, respectively. Building on this new paradigm, we propose DHCG: Dynamic construction of Hierarchical Collaboration Graphs for MAS. We formulate MAS construction as a partially observable Markov decision process, in which a Planner makes sequential decisions based on the query and evolving execution feedback. At each layer, the Planner generates complementary roles for unresolved reasoning needs, assigns relevant predecessors through dependency-aware instructions, and decides whether to expand or finalize the graph. Consequently, both the collaboration structure and scale evolve with the reasoning process. Training such a sequential construction policy online is expensive. We therefore devise an offline action-aware preference optimization strategy that reuses collected trajectory trees to construct multiple preference pairs from relatively few trajectories. It evaluates alternative Planner actions through downstream outcomes, constructs within- and cross-action preferences, and weights the pairs by their value gaps. This offline training strategy guides the Planner toward more effective role-generation, dependency-routing, and finalization decisions. Empirical results show that DHCG achieves the highest average performance, outperforming the strongest static, workflow-based, and graph-based MAS baselines by 4.76, 2.77, and 3.33 points, respectively. The framework also generalizes across Planner backbones and transfers effectively to unseen Worker models. Additional analyses show that DHCG adapts its collaboration structure and scale to task difficulty. Our main contributions are summarized as follows: • We introduce an inference-time dynamic graph construction paradigm for MAS design, where collaboration structures are progressively constructed according to the query and real-time execution feedback, rather than being fully specified before execution. • We propose DHCG, a Planner-driven framework that formulates MAS construction as a POMDP and adaptively determines roles, dependencies, and graph scale. We further introduce offline action-aware preference optimization, which derives within- and cross-action preferences from downstream trajectory quality and action-level execution cost. • We evaluate DHCG on seven benchmarks spanning mathematical reasoning, code generation, and general knowledge. The results validate DHCG’s effectiveness and its generalization across Planner backbones and unseen Worker models. Additional analyses show that DHCG adapts its collaboration structure and scale to task difficulty. 2 Related Work Static and Dynamic MAS Construction. Early MAS frameworks organize collaboration through predefined roles and protocols. CAMEL (Li et al. 2023) and AutoGen (Wu et al. 2024) support structured agent interactions, while MetaGPT (Hong et al. 2024) coordinates specialized agents through standardized operating procedures. Such static designs rely heavily on manual specification and offer limited adaptability across tasks. Recent dynamic MAS methods seek to replace manually specified collaboration structures with automatically optimized designs. At the topology level, GPTSwarm (Zhuge et al. 2024) and G-Designer (Zhang et al. 2025c) learn task-adaptive communication structures, while AgentPrune (Zhang et al. 2025b) and AgentDropout (Wang et al. 2025d) prune redundant agents or edges. At the workflow level, ADAS (Hu et al. 2025) and AFlow (Zhang et al. 2025d) search for executable procedures, whereas MASS (Zhou et al. 2026) and MaAS (Zhang et al. 2025a) optimize broader agent configurations and orchestration. These methods reduce manual design and improve task-specific coordination, but predefined components or search spaces still limit adaptation during execution. Policy Optimization for MAS Construction. Recent studies increasingly formulate MAS construction as a learnable decision-making process. One line of work optimizes policies for generating complete workflows or global collaboration structures. ScoreFlow (Wang et al. 2025c) learns workflow generation from execution-score-derived preferences, while MAS2 (Wang et al. 2025a) combines collaborative tree search with value-guided optimization to train multiple Meta-Agents. AgentConductor (Wang et al. 2026) further introduces difficulty-aware rewards for optimizing layered communication topologies. Another line of work focuses on sequential construction guided by intermediate feedback. DyFlow (Wang et al. 2025b) trains a Designer through distilled self-play to adapt its planning decisions, whereas Workflow-R1 (Kong et al. 2026) and FlowSteer (Zhang et al. 2026) optimize multi-turn workflow construction through sub-sequence policy updates and atomic workflow editing, respectively. Collectively, these studies demonstrate the effectiveness of policy optimization for automated MAS construction. However, the former provides only coarse supervision at the workflow or structure level, while the latter focuses on sequential refinement and offers limited modeling of evolving inter-agent dependencies. Figure 2: Overview of DHCG. (a) The Planner dynamically initializes, expands, and finalizes the hierarchical collaboration graph during inference. (b) The Planner is trained from tree-structured trajectories via action-aware preference optimization. 3 Methodology 3.1 Problem Formulation Hierarchical Collaboration Graph. We model multi-agent collaboration as a hierarchical directed acyclic graph G=(V,E)G=(V,E). Each node vi∈Vv_i∈ V denotes an agent execution, and each edge (vj,vi)∈E(v_j,v_i)∈ E routes the output of vjv_j to viv_i, thereby defining an information dependency. Agent viv_i is specified by a language model policy πθi _ _i and an instruction prompt pip_i. Given the original task q, its routed context and output are defined as xi=yj∣(vj,vi)∈E,yi∼πθi(⋅∣q,pi,xi),x_i=\y_j (v_j,v_i)∈ E\, y_i _ _i(· q,p_i,x_i), (1) where xix_i collects the outputs yjy_j routed from the predecessors of viv_i, and yiy_i denotes the output generated by viv_i. For a node without incoming edges, xi=∅x_i= . To distinguish sequential dependencies across reasoning stages from parallel collaboration within the same stage, we partition G into layers: V=⨆l=0LVl,E⊆⋃l=1L(Vl−1×Vl),V= _l=0^LV_l, E _l=1^L (V_l-1× V_l ), (2) where VlV_l denotes nodes in layer l, L is the maximum layer index, and E denotes inter-layer edges. This constraint excludes intra-layer dependencies, allowing agents in the same layer to execute in parallel. Dynamic Graph Construction as a POMDP. Rather than determining all agent nodes and dependencies before execution, we formulate collaboration graph construction as a sequential decision process in which a planner adapts the graph according to intermediate agent outputs. We model this process as a partially observable Markov decision process (POMDP): ℳ=⟨,,T,R,Ω,O,γ⟩,M= ,A,T,R, ,O,γ , (3) where S is the latent state space of graph construction, A is the Planner action space, T is the transition function, Ω is the observation space, and O is the observation function. The reward function R reflects downstream task performance and execution cost, while γ is the discount factor. At decision step t, the latent state st∈s_t summarizes the graph-construction history, accumulated agent outputs, and unobserved reasoning conditions. The Planner observes the query and the role-output pairs from the most recently executed layer: ot=O(st)=(q,∅),t=0,(q,t−1),t≥1,ot∈Ω,o_t=O(s_t)= cases(q, ),&t=0,\\ (q,Z_t-1),&t≥ 1, cases o_t∈ , (4) where t−1=(ρi,yi)∣vi∈Vt−1Z_t-1=\( _i,y_i) v_i∈ V_t-1\, with ρi _i and yiy_i denoting the role specification and output of agent node viv_i. Conditioned on oto_t, the planner selects an action and transitions to the next state: at∼πθ(⋅∣ot),st+1∼T(⋅∣st,at),a_t _θ(· o_t), s_t+1 T(· s_t,a_t), (5) where πθ _θ is the planner policy, ata_t is the selected construction action, and T describes the transition induced by the action and subsequent agent execution. 3.2 Dynamic Hierarchical Collaboration Graph Overview. Building on the POMDP formulation, we propose DHCG, a framework that dynamically constructs hierarchical collaboration graphs for MAS. As shown in Figure 2(a), DHCG consists of a Planner, Workers, and a Generator. Based on the query and evolving execution feedback, the Planner incrementally generates task-specific roles, specifies inter-layer dependencies, and decides whether to expand or finalize the graph. Workers execute the generated roles to produce intermediate outputs, while the Generator synthesizes the final answer from the outputs selected by the Planner. This design enables parallel intra-layer collaboration and hierarchical inter-layer information flow. Initial Layer Construction. The initial layer provides a set of independent and complementary perspectives for addressing the input query. Since communication dependencies may propagate and amplify errors introduced at early reasoning stages (Shen et al. 2025), DHCG avoids premature information coupling by allowing the initial agents to reason independently. Meanwhile, the required perspectives can vary across queries. Rather than relying on fixed agent configurations or constructing structures solely from learned query representations (e.g., embeddings) (Su et al. 2026), DHCG employs a Planner to analyze the task-specific reasoning requirements of each query. Based on this analysis, the Planner determines both the number of initial agents and the complementary roles. Formally, given the input query q, the Planner generates the initial layer as V0=vi=(ρi,pi)i=1n0∼πθinit(⋅∣q),V_0=\v_i=( _i,p_i)\_i=1^n_0 _θ^init(· q), (6) where n0n_0 denotes the number of agents, while ρi _i and pip_i denote the role specification and instruction prompt of agent viv_i, respectively. The corresponding Workers are instantiated from these nodes and execute their assigned roles in parallel. Let yi(0)y_i^(0) denote the output produced by the Worker associated with node viv_i in the initial layer. The resulting role-output pairs are collected as 0=(ρi,yi(0))i=1n0,Z_0=\( _i,y_i^(0))\_i=1^n_0, (7) which are passed to the Planner for subsequent planning steps. Dynamic Planning and Graph Construction. After executing the initial layer, DHCG continues graph construction based on the latest execution feedback. Fixed interaction rounds or execution stages may lead to unnecessary computation for simple queries or insufficient reasoning for complex ones (Wang et al. 2025d). Moreover, dense or predefined communication structures may introduce redundant information or fail to provide the evidence required by downstream agents (Qian et al. 2025). Accordingly, DHCG adaptively determines whether to finalize or expand the graph and, when expanding, establishes sparse inter-layer dependencies by routing relevant outputs from the preceding layer to each newly generated role. Formally, after layer Vt−1V_t-1 is executed, the Planner observes the query q and the latest role-output pairs t−1Z_t-1, and samples a dynamic planning action: at∼πθdyn(⋅∣q,t−1),at∈t,a_t _θ^dyn(· q,Z_t-1), a_t _t, (8) where the action space is defined as t=FINALIZE(Ct−1),Ct−1⊆Vt−1,EXPAND(Vt,Et),Et⊆Vt−1×Vt.A_t= \ array[]lFINALIZE(C_t-1),&C_t-1 V_t-1,\\[2.0pt] EXPAND(V_t,E_t),&E_t V_t-1× V_t. array . (9) If the Planner selects FINALIZE(Ct−1)FINALIZE(C_t-1), the construction process is terminated and the selected source agents are used for final answer synthesis. Otherwise, if the Planner selects EXPAND(Vt,Et)EXPAND(V_t,E_t), it generates a new layer of agents: Vt=vi(t)=(ρi(t),pi(t))i=1nt,V_t= \v_i^(t)= ( _i^(t),p_i^(t) ) \_i=1^n_t, (10) where ntn_t denotes the number of newly generated agents in layer t. For each new agent vi(t)v_i^(t), the Planner selects only the necessary source agents from the previous layer, denoted by i(t)⊆Vt−1S_i^(t) V_t-1. Agents whose outputs are irrelevant, redundant, or unnecessary for vi(t)v_i^(t) are not connected. The corresponding sparse routing edges are then constructed as Et=(vj,vi(t))∣vi(t)∈Vt,vj∈i(t).E_t=\(v_j,v_i^(t)) v_i^(t)∈ V_t,\;v_j _i^(t)\. (11) The instruction prompt pi(t)p_i^(t) specifies both the new agent’s role and how it should process the routed source outputs, such as by verifying, refining, comparing, or synthesizing them. The corresponding Workers are then instantiated to execute these roles, producing role–output pairs. These role–output pairs are returned to the Planner for the next decision step, enabling DHCG to progressively adapt the collaboration graph according to the evolving intermediate results. Answer Synthesis. DHCG employs a dedicated Generator to produce a stable and well-formatted final response. Upon FINALIZE(Ct−1)FINALIZE(C_t-1), only the selected role-output pairs in Ct−1C_t-1 are provided to the Generator; if the maximum layer L is reached, all outputs in VLV_L are used instead. This design filters redundant context and enables focused answer synthesis. 3.3 Planner Training The Planner jointly determines construction actions, agent roles, and routing dependencies, which directly affect both the collaboration graph and final answer quality. Inspired by tree-based preference construction (Wang et al. 2025a), we propose Action-aware Preference Optimization to train the Planner from the downstream outcomes of alternative construction decisions. As shown in Figure 2(b), we first collect tree-structured trajectories by recursively sampling and executing alternative Planner actions. We then construct action-aware preference pairs and optimize the Planner according to their relative advantages. Action-aware Preference Construction. Given a planning observation oto_t, we sample multiple candidate Planner outputs and recursively execute them to construct a tree of alternative graph-construction trajectories. Each node ntn_t represents a candidate Planner action at construction step t. We recursively estimate the value of each candidate action as Vt=r−λ⋅CT,t=T,γ⋅V¯t+1−λ⋅Ct,t<T,V_t= casesr-λ· C_T,&t=T,\\[2.84526pt] γ· V_t+1-λ· C_t,&t<T, cases (12) where r∈[0,1]r∈[0,1] denotes the final-answer score, CtC_t is the token cost incurred by the current Planner action, λ controls the trade-off between accuracy and efficiency, and γ∈(0,1]γ∈(0,1] is the discount factor. Here, V¯t+1 V_t+1 denotes the average recursively estimated value of the directly sampled child actions. We construct preferences based on the action types being compared. Cross-action pairs, primarily Expand–Finalize, use task-only values to avoid favoring Finalize due to lower cost, whereas same-action pairs use cost-aware values to account for execution efficiency. We retain only pairs with sufficiently large value gaps and discard same-action pairs when both candidates have zero downstream task scores. Algorithm 1 DHCG Inference 0: Query q; maximum layer L; width budget W 0: Final answer y y and collaboration graph G 1: Step 1: Initial Layer Construction 2: V0←Plannerinit(q),|V0|≤W,G←(V0,∅)V_0 _init(q), |V_0|≤ W, G←(V_0, ) 3: 0←Workers(q,V0),C←V0Z_0 (q,V_0), C← V_0 4: Step 2: Dynamic Graph Construction 5: for t=1t=1 to L do 6: at←Plannerdyn(q,t−1)a_t _dyn(q,Z_t-1) 7: if at=FINALIZE(Ct−1),Ct−1⊆Vt−1a_t=FINALIZE(C_t-1), C_t-1 V_t-1 then 8: C←Ct−1C← C_t-1; break 9: end if 10: (Vt,Et)←at,|Vt|≤W,G←G∪(Vt,Et)(V_t,E_t)← a_t, |V_t|≤ W, G← G∪(V_t,E_t) 11: t←Workers(q,Vt,Et,t−1),C←VtZ_t (q,V_t,E_t,Z_t-1), C← V_t 12: end for 13: Step 3: Answer Synthesis 14: y^←Generator(q,Outputs(C)) y (q,Outputs(C)) 15: return (y^,G)( y,G) Method MBPP HumanEval MATH-500 AIME GSM8K GPQA MMLU-Pro Average IO 63.73 82.70 81.20 17.78 88.09 37.54 51.57 60.37 CoT 70.48↑6.75 \!6.75 85.75↑3.05 \!3.05 84.60↑3.40 \!3.40 18.89↑1.11 \!1.11 92.58↑4.49 \!4.49 39.90↑2.36 \!2.36 54.29↑2.72 \!2.72 63.78↑3.41 \!3.41 CoT-SC 71.36↑7.63 \!7.63 86.01↑3.31 \!3.31 88.47↑7.27 \!7.27 25.56↑7.78 \!7.78 93.90↑5.81 \!5.81 52.02↑14.48 \!14.48 64.95↑13.38 \!13.38 68.90↑8.52 \!8.52 LLM-Debate 71.07↑7.34 \!7.34 88.04↑5.34 \!5.34 88.60↑7.40 \!7.40 23.33↑5.55 \!5.55 94.19↑6.10 \!6.10 52.53↑14.99 \!14.99 62.95↑11.38 \!11.38 68.67↑8.30 \!8.30 MacNet 68.33↑4.60 \!4.60 84.48↑1.78 \!1.78 86.00↑4.80 \!4.80 26.67↑8.89 \!8.89 91.53↑3.44 \!3.44 49.66↑12.12 \!12.12 63.57↑12.00 \!12.00 67.18↑6.80 \!6.80 G-Designer 78.59↑14.86 \!14.86 85.49↑2.79 \!2.79 87.80↑6.60 \!6.60 25.56↑7.78 \!7.78 93.37↑5.28 \!5.28 53.54↑16.00 \!16.00 66.38↑14.81 \!14.81 70.10↑9.73 \!9.73 ARG-Designer 72.63↑8.90 \!8.90 86.26↑3.56 \!3.56 83.60↑2.40 \!2.40 20.00↑2.22 \!2.22 91.34↑3.25 \!3.25 53.37↑15.83 \!15.83 64.81↑13.24 \!13.24 67.43↑7.06 \!7.06 AFlow 72.33↑8.60 \!8.60 84.48↑1.78 \!1.78 87.07↑5.87 \!5.87 21.11↑3.33 \!3.33 92.86↑4.77 \!4.77 43.10↑5.56 \!5.56 56.95↑5.38 \!5.38 65.41↑5.04 \!5.04 MaAS 82.01↑18.28 \!18.28 89.82↑7.12 \!7.12 87.33↑6.13 \!6.13 28.89↑11.11 \!11.11 92.89↑4.80 \!4.80 49.83↑12.29 \!12.29 63.86↑12.29 \!12.29 70.66↑10.29 \!10.29 DHCG (Ours) 84.36↑20.63 \!20.63 93.13↑10.43 \!10.43 88.73↑7.53 \!7.53 30.00↑12.22 \!12.22 93.93↑5.84 \!5.84 55.89↑18.35 \!18.35 68.00↑16.43 \!16.43 73.43↑13.06 \!13.06 Table 1: Performance comparison (%) on seven benchmarks. Action-aware Preference Optimization. Each retained preference pair is represented as (oi,ai+,ai−,wi)(o_i,a_i^+,a_i^-,w_i), where wiw_i is obtained by clipping the corresponding value gap. We use a smaller clipping threshold for same-action pairs, which are more frequent and partially reflect efficiency differences. The resulting weights are normalized by their mean over the training set, yielding w~i w_i. Let πref _ref denote the frozen reference Planner. For the i-th preference pair, we define the relative log-likelihood difference as Δρθ(i)=logπθ(ai+∣oi)πref(ai+∣oi)−logπθ(ai−∣oi)πref(ai−∣oi). _θ^(i)= _θ(a_i^+ o_i) _ref(a_i^+ o_i)- _θ(a_i^- o_i) _ref(a_i^- o_i). (13) The Planner is optimized using the weighted DPO for action-aware preference optimization: ℒAPO=−1N∑i=1Nw~ilogσ(βΔρθ(i)),L_APO=- 1N _i=1^N w_i σ (β _θ^(i) ), (14) where σ is the sigmoid function and β controls the strength of preference separation relative to the reference Planner. Cross-action preferences teach the Planner whether further graph expansion is beneficial or the current graph should be finalized, whereas same-action preferences help it distinguish among alternative decisions of the same type by considering both downstream task performance and execution efficiency. 4 Experiments 4.1 Experiment Setup Benchmarks. To comprehensively evaluate DHCG, we conduct experiments on seven benchmarks spanning three reasoning domains. For code reasoning, we use HumanEval (Chen et al. 2021) and MBPP (Austin et al. 2021). For mathematical reasoning, we adopt MATH-500 (Lightman et al. 2024) to assess general mathematical problem solving, GSM8K (Cobbe et al. 2021) to evaluate multi-step arithmetic reasoning, and AIME 2025 (Mathematical Association of America 2025) to probe performance on challenging competition-level problems. For knowledge-intensive reasoning, we use GPQA Diamond (Rein et al. 2024) to evaluate graduate-level scientific reasoning and MMLU-Pro (Wang et al. 2024) to assess complex discipline reasoning. Baselines. We compare DHCG with representative baselines from four categories. Single-model prompting includes IO (direct LLM invocation), Chain-of-Thought (Wei et al. 2022), and Self-Consistency CoT (5 answers) (Wang et al. 2023). Static MAS include LLM-Debate (Du et al. 2024) and MacNet (Qian et al. 2025). Graph-based MAS include G-Designer (Zhang et al. 2025c) and ARG-Designer (Li et al. 2026). Workflow-based MAS include AFlow (Zhang et al. 2025d) and MaAS (Zhang et al. 2025a). For a fair comparison, all agent types in every method use the same LLM backbone and identical inference configurations. Details of benchmark curation, data splits, baseline configurations, and evaluation protocols are provided in Appendix A. Implementation Details. Our Planner is fine-tuned from Qwen3-8B (Yang et al. 2025), while both the Workers and Generator use the original Qwen3-8B model. All experiments are conducted over three independent runs, and we report the average performance. For Planner training, we sample the training data from DeepMath-103K (He et al. 2025) and KodCode (Xu et al. 2025). Details of the training-data composition, selection and preprocessing procedures, preference-data construction, and optimization configurations are provided in Appendix B. 4.2 Experimental Results Overall Performance. Table 1 reports the results across seven benchmarks. DHCG achieves the highest average accuracy of 73.43%, outperforming the strongest static MAS method, LLM-Debate, by 4.76 points, the strongest graph-based method, G-Designer, by 3.33 points, and the strongest workflow-based method, MaAS, by 2.77 points. Among the baselines, MaAS performs particularly well on code-generation tasks, while G-Designer is strong on knowledge-intensive reasoning. DHCG achieves strong performance across code generation, mathematical reasoning, and knowledge-intensive reasoning, demonstrating the effectiveness of dynamically constructing collaboration graphs according to evolving reasoning states. Notably, although the Planner is trained only on mathematical and code-generation data, DHCG remains highly competitive on GPQA and MMLU-Pro, indicating effective cross-domain generalization. This generalization is supported by DHCG’s dynamic graph construction, which adapts roles and dependencies to evolving reasoning needs. Empirical Upper Bound. Table 2 reports the Pass@5 results of DHCG and CoT under repeated sampling. DHCG consistently outperforms CoT across all three benchmarks, indicating a higher probability of obtaining a correct solution over multiple runs. This advantage stems from the diverse collaboration graphs and reasoning paths constructed across different runs. In particular, DHCG achieves a Pass@5 of 98.47% on HumanEval, demonstrating a strong empirical upper bound for code generation. The improvements on MATH-500 and MMLU-Pro further show that this advantage extends to mathematical reasoning and multi-domain knowledge reasoning. Method HumanEval MATH-500 MMLU-Pro Avg. CoT 92.37 93.40 74.68 86.82 DHCG 98.47 95.20 81.71 91.79 Table 2: Pass@5 performance (%) on three representative benchmarks. 4.3 Generalization Analysis Cross-Planner Generalization. To assess the robustness of DHCG to different Planner backbones, we instantiate the framework with three distinct models: GPT-5.4-mini (Singh et al. 2025), DeepSeek-V4-Pro (DeepSeek-AI 2026), and our trained Qwen3-8B Planner. As shown in Table 3, all three variants achieve higher average accuracy than the strongest baseline, MaAS, indicating that DHCG is not tied to a specific Planner model and generalizes well across different Planner families. Moreover, although our Planner is trained from the smaller 8B backbone, it achieves an average score comparable to those achieved by larger Planner models. These results suggest that our training strategy can effectively elicit the planning capability of a compact model, enabling competitive performance without relying on large-scale Planner models. Method MBPP AIME MMLU-Pro Avg. MaAS 82.01 28.89 63.86 58.25 DHCG (GPT-5.4-mini) 84.16 28.89 69.24 60.76 DHCG (DS-V4-Pro) 83.97 28.89 69.48 60.78 DHCG (Qwen3-8B†) 84.36 30.00 68.00 60.79 Table 3: Cross-Planner generalization of DHCG and comparison with baselines (%) on three benchmarks. † denotes our Planner trained from the Qwen3-8B backbone. Cross-Worker Generalization. We further investigate whether DHCG is sensitive to the choice of Worker model. To this end, we keep the trained Planner fixed and pair it with DeepSeek-V4-Pro and GPT-5.4-mini as Workers, respectively. As shown in Figure 3, DHCG consistently outperforms the corresponding single-model CoT baseline across the evaluated benchmarks, although the magnitude of improvement varies by task. These results demonstrate that the learned graph-construction policy can effectively generalize across different Worker backbones, improving reasoning quality while maintaining robust and consistent performance. Figure 3: Cross-worker generalization of DHCG against the corresponding single-model CoT baselines. Method MMLU-Pro GSM8K HumanEval Avg. Planner Training Base Planner 67.14 93.55 91.35 84.01 SFT 66.29 93.81 88.30 82.80 Vanilla DPO 66.71 93.40 92.37 84.16 Graph Construction w/o Dyn. Routing 67.00 93.71 91.86 84.19 w/o Dyn. Scale 65.62 92.76 88.80 82.39 w/o Dyn. Role 66.19 93.78 89.31 83.09 DHCG 68.00 93.93 93.13 85.02 Table 4: Ablation results (%) on three representative benchmarks. 4.4 Ablation Study Planner Training. We compare the base Planner, SFT, vanilla DPO, and our action-aware preference optimization. As shown in Table 4, SFT reduces the average performance by 1.21, including a 3.05 drop on HumanEval. Since SFT optimizes token-level imitation, the Planner may overfit to specific planning patterns, reducing its ability to adapt its decisions to evolving execution feedback. This observation also supports our choice to directly optimize the base Planner through reinforcement learning, rather than adopting the conventional SFT-then-RL training paradigm. Vanilla DPO uses the same value-based preference pairs as our method but assigns a uniform weight to every pair. Its slight improvement over the base Planner confirms the effectiveness of our preference construction. Our complete method further weights each pair according to its value gap and achieves the best average score, demonstrating the additional benefit of distinguishing preference strength during optimization. Graph Construction. We ablate dynamic routing, graph-scale control, and dynamic role generation by replacing them with fixed alternatives. Removing any of these dynamic components leads to performance degradation to varying degrees. Among them, dynamic graph-scale control has the largest overall impact, with its removal reducing average performance by 2.63 and HumanEval performance by 4.33. This highlights the necessity of adapting the collaboration scale to evolving reasoning requirements rather than determining it in advance. Together, these results show that dynamic scale, role generation, and routing provide complementary benefits for constructing effective collaboration graphs. 4.5 Framework Analysis Figure 4: Performance and total token cost comparison. Cost Analysis. DHCG dynamically adapts the collaboration graph to task-specific reasoning requirements, allocating different amounts of computational resources across queries. As shown in Figure 4, fixed graph templates and static MAS methods can introduce substantial redundant communication. This advantage is particularly evident on MMLU-Pro, where DHCG outperforms G-Designer with over 50% fewer tokens and achieves higher accuracy than MacNet while reducing token consumption by 32.16%. A similar accuracy–efficiency advantage is observed on MATH-500, where DHCG surpasses MaAS with comparable token usage, whereas AFlow consumes fewer tokens but achieves lower accuracy. Overall, these results demonstrate that dynamic graph construction improves the balance between reasoning performance and computational cost. Difficulty-Aware Graph Construction. We further examine whether DHCG adapts its collaboration graph to problem difficulty. Both the MATH-500 trend analysis and qualitative case study show that DHCG constructs larger graphs with more Workers for harder problems, while maintaining compact structures for easier ones. These results demonstrate that DHCG dynamically allocates computational resources according to reasoning difficulty. Additional quantitative and qualitative analyses are provided in Appendix C. 5 Conclusion In this work, we proposed DHCG, a novel framework for the dynamic construction of hierarchical collaboration graphs in MAS. We formulated MAS construction as a partially observable Markov decision process and introduced a new paradigm in which the collaboration graph is progressively constructed during execution. DHCG employs a Planner to generate task-specific roles, determine dependency routing, and control graph scale through sequential expansion and finalization decisions based on evolving execution feedback, while optimizing the planning policy through action-aware preference optimization. Extensive experiments demonstrate DHCG’s effectiveness and generalization across Planner backbones and unseen Worker models, with our compact Planner performing comparably to larger ones. Acknowledgement This work is supported by the National Key R&D Program of China (No. 2026YFE0101200), and the National Natural Science Foundation of China (No. 62671175). The computations in this research were performed using the CFFF platform of Fudan University. References Austin et al. (2021) J. Austin, A. Odena, M. Nye, M. Bosma, H. Michalewski, D. Dohan, E. Jiang, C. Cai, M. Terry, Q. V. Le, and C. Sutton Program synthesis with large language models. arXiv preprint arXiv:2108.07732. External Links: 2108.07732, Document, Link Cited by: §4.1. Chen et al. (2021) M. Chen, J. Tworek, H. Jun, et al. Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374. External Links: 2107.03374, Document, Link Cited by: §4.1. Cobbe et al. (2021) K. Cobbe, V. Kosaraju, M. Bavarian, M. Chen, H. Jun, L. Kaiser, M. Plappert, J. Tworek, J. Hilton, R. Nakano, C. Hesse, and J. Schulman Training verifiers to solve math word problems. arXiv preprint arXiv:2110.14168. External Links: 2110.14168, Document, Link Cited by: §4.1. DeepSeek-AI (2026) DeepSeek-AI DeepSeek-v4: towards highly efficient million-token context intelligence. arXiv preprint arXiv:2606.19348. Cited by: §4.3. Du et al. (2024) Y. Du, S. Li, A. Torralba, J. B. Tenenbaum, and I. Mordatch Improving factuality and reasoning in language models through multiagent debate. In Proceedings of the 41st International Conference on Machine Learning, Proceedings of Machine Learning Research, Vol. 235, p. 11733–11763. External Links: Link Cited by: §4.1. He et al. (2025) Z. He, T. Liang, J. Xu, Q. Liu, X. Chen, Y. Wang, L. Song, D. Yu, Z. Liang, W. Wang, Z. Zhang, R. Wang, Z. Tu, H. Mi, and D. Yu DeepMath-103K: a large-scale, challenging, decontaminated, and verifiable mathematical dataset for advancing reasoning. arXiv preprint arXiv:2504.11456. External Links: 2504.11456, Document, Link Cited by: §4.1. Hong et al. (2024) S. Hong, M. Zhuge, J. Chen, X. Zheng, Y. Cheng, C. Zhang, J. Wang, Z. Wang, S. K. S. Yau, Z. Lin, L. Zhou, C. Ran, L. Xiao, C. Wu, and J. Schmidhuber MetaGPT: meta programming for a multi-agent collaborative framework. In The Twelfth International Conference on Learning Representations, External Links: Link Cited by: §1, §2. Hu et al. (2025) S. Hu, C. Lu, and J. Clune Automated design of agentic systems. In The Thirteenth International Conference on Learning Representations, External Links: 2408.08435, Link Cited by: §1, §2. Hu et al. (2026) Y. Hu, Y. Zhang, M. Trager, Y. Zhang, S. Yang, W. Xia, and S. Soatto EvoMAS: evolutionary generation of multi-agent systems. arXiv preprint arXiv:2602.06511. External Links: 2602.06511, Document, Link Cited by: §1. Kong et al. (2026) M. Kong, Z. Qu, Z. Zhou, P. Liang, X. Li, Z. Shang, Z. Hong, K. Huang, Z. Wang, and Z. Dai Workflow-R1: group sub-sequence policy optimization for multi-turn workflow construction. arXiv preprint arXiv:2602.01202. External Links: 2602.01202, Document, Link Cited by: §2. Li et al. (2023) G. Li, H. A. A. K. Hammoud, H. Itani, D. Khizbullin, and B. Ghanem CAMEL: communicative agents for “mind” exploration of large language model society. In Advances in Neural Information Processing Systems, Vol. 36. External Links: Document, Link Cited by: §1, §2. Li et al. (2026) S. Li, Y. Liu, Q. Wen, C. Zhang, and S. Pan Assemble your crew: automatic multi-agent communication topology design via autoregressive graph generation. Proceedings of the AAAI Conference on Artificial Intelligence 40 (28), p. 23142–23150. External Links: Document, Link Cited by: §1, §4.1. Lightman et al. (2024) H. Lightman, V. Kosaraju, Y. Burda, H. Edwards, B. Baker, T. Lee, J. Leike, J. Schulman, I. Sutskever, and K. Cobbe Let’s verify step by step. In The Twelfth International Conference on Learning Representations, External Links: Link Cited by: §4.1. Mathematical Association of America (2025) Mathematical Association of America American invitational mathematics examination (AIME). Note: MAA Invitational Competitions External Links: Link Cited by: §4.1. Qian et al. (2025) C. Qian, Z. Xie, Y. Wang, W. Liu, K. Zhu, H. Xia, Y. Dang, Z. Du, W. Chen, C. Yang, Z. Liu, and M. Sun Scaling large language model-based multi-agent collaboration. In The Thirteenth International Conference on Learning Representations, External Links: Link Cited by: §3.2, §4.1. Rein et al. (2024) D. Rein, B. L. Hou, A. C. Stickland, J. Petty, R. Y. Pang, J. Dirani, J. Michael, and S. R. Bowman GPQA: a graduate-level google-proof Q&A benchmark. In Proceedings of the First Conference on Language Modeling, External Links: Link Cited by: §4.1. Schick et al. (2023) T. Schick, J. Dwivedi-Yu, R. Dessì, R. Raileanu, M. Lomeli, E. Hambro, L. Zettlemoyer, N. Cancedda, and T. Scialom Toolformer: language models can teach themselves to use tools. In Advances in Neural Information Processing Systems, Vol. 36. External Links: Link Cited by: §1. Shen et al. (2025) X. Shen, Y. Liu, Y. Dai, Y. Wang, R. Miao, Y. Tan, S. Pan, and X. Wang Understanding the information propagation effects of communication topologies in LLM-based multi-agent systems. In Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing, Suzhou, China, p. 12347–12361. External Links: Document, Link Cited by: §3.2. Shinn et al. (2023) N. Shinn, F. Cassano, A. Gopinath, K. Narasimhan, and S. Yao Reflexion: language agents with verbal reinforcement learning. In Advances in Neural Information Processing Systems, Vol. 36. External Links: Document, Link Cited by: §1. Singh et al. (2025) A. Singh, A. Fry, A. Perelman, A. Tart, A. Ganesh, A. El-Kishky, A. McLaughlin, A. Low, A. Ostrow, A. Ananthram, et al. Openai gpt-5 system card. arXiv preprint arXiv:2601.03267. Cited by: §4.3. Su et al. (2026) J. Su, Q. Lan, Y. Xia, L. Sun, W. Tian, T. Shi, and L. He Difficulty-aware agentic orchestration for query-specific multi-agent workflows. In Proceedings of the ACM Web Conference 2026, p. 2060–2070. External Links: Document, Link Cited by: §3.2. Team et al. (2025) I. Team, B. Zhang, S. Feng, X. Yan, J. Yuan, R. Ma, Y. Hu, Z. Yu, X. He, S. Huang, et al. InternAgent: when agent becomes the scientist–building closed-loop system from hypothesis to verification. arXiv preprint arXiv:2505.16938. Cited by: §1. Wang et al. (2025a) K. Wang, G. Zhang, M. Ye, X. Deng, D. Wang, X. Hu, J. Guo, Y. Liu, and Y. Guo MAS2^2: self-generative, self-configuring, self-rectifying multi-agent systems. arXiv preprint arXiv:2509.24323. External Links: 2509.24323, Document, Link Cited by: §1, §2, §3.3. Wang et al. (2026) S. Wang, R. Lu, Z. Yang, Y. Wang, Y. Zhang, L. Xu, Q. Xu, G. Yin, C. Chen, and X. Guan AgentConductor: topology evolution for multi-agent competition-level code generation. arXiv preprint arXiv:2602.17100. External Links: 2602.17100, Document, Link Cited by: §2. Wang et al. (2023) X. Wang, J. Wei, D. Schuurmans, Q. V. Le, E. H. Chi, S. Narang, A. Chowdhery, and D. Zhou Self-consistency improves chain of thought reasoning in language models. In The Eleventh International Conference on Learning Representations, External Links: Link Cited by: §4.1. Wang et al. (2025b) Y. Wang, Z. Xu, Y. Huang, X. Wang, Z. Song, L. Gao, C. Wang, X. Tang, Y. Zhao, A. Cohan, X. Zhang, and X. Chen DyFlow: dynamic workflow framework for agentic reasoning. arXiv preprint arXiv:2509.26062. External Links: 2509.26062, Document, Link Cited by: §2. Wang et al. (2025c) Y. Wang, L. Yang, G. Li, M. Wang, and B. Aragam ScoreFlow: mastering LLM agent workflows via score-based preference optimization. arXiv preprint arXiv:2502.04306. External Links: 2502.04306, Document, Link Cited by: §2. Wang et al. (2024) Y. Wang, X. Ma, G. Zhang, Y. Ni, A. Chandra, S. Guo, W. Ren, A. Arulraj, X. He, Z. Jiang, T. Li, M. Ku, K. Wang, A. Zhuang, R. Fan, X. Yue, and W. Chen MMLU-Pro: a more robust and challenging multi-task language understanding benchmark. In Advances in Neural Information Processing Systems, Vol. 37. External Links: Document, Link Cited by: §4.1. Wang et al. (2025d) Z. Wang, Y. Wang, X. Liu, L. Ding, M. Zhang, J. Liu, and M. Zhang AgentDropout: dynamic agent elimination for token-efficient and high-performance LLM-based multi-agent collaboration. In Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), Vienna, Austria, p. 24013–24035. External Links: Document, Link Cited by: §2, §3.2. Wei et al. (2022) J. Wei, X. Wang, D. Schuurmans, M. Bosma, B. Ichter, F. Xia, E. H. Chi, Q. V. Le, and D. Zhou Chain-of-thought prompting elicits reasoning in large language models. In Advances in Neural Information Processing Systems, Vol. 35, p. 24824–24837. External Links: Document, Link Cited by: §4.1. Wu et al. (2024) Q. Wu, G. Bansal, J. Zhang, Y. Wu, B. Li, E. Zhu, L. Jiang, X. Zhang, S. Zhang, J. Liu, A. H. Awadallah, R. W. White, D. Burger, and C. Wang AutoGen: enabling next-gen LLM applications via multi-agent conversations. In Proceedings of the First Conference on Language Modeling, External Links: Link Cited by: §1, §2. Xu et al. (2025) Z. Xu, Y. Liu, Y. Yin, M. Zhou, and R. Poovendran KodCode: a diverse, challenging, and verifiable synthetic dataset for coding. In Findings of the Association for Computational Linguistics: ACL 2025, Vienna, Austria, p. 6980–7008. External Links: Document, Link Cited by: §4.1. Yang et al. (2025) A. Yang, A. Li, B. Yang, B. Zhang, B. Hui, B. Zheng, B. Yu, et al. Qwen3 Technical Report. arXiv preprint arXiv:2505.09388. External Links: 2505.09388, Document, Link Cited by: §4.1. Yao et al. (2023) S. Yao, J. Zhao, D. Yu, N. Du, I. Shafran, K. Narasimhan, and Y. Cao ReAct: synergizing reasoning and acting in language models. In The Eleventh International Conference on Learning Representations, External Links: Link Cited by: §1. Zhang et al. (2025a) G. Zhang, L. Niu, J. Fang, K. Wang, L. Bai, and X. Wang Multi-agent architecture search via agentic supernet. In Proceedings of the 42nd International Conference on Machine Learning, Proceedings of Machine Learning Research, Vol. 267, p. 75834–75852. External Links: Link Cited by: §2, §4.1. Zhang et al. (2025b) G. Zhang, Y. Yue, Z. Li, S. Yun, G. Wan, K. Wang, D. Cheng, J. X. Yu, and T. Chen Cut the crap: an economical communication pipeline for LLM-based multi-agent systems. In The Thirteenth International Conference on Learning Representations, External Links: 2410.02506, Link Cited by: §1, §2. Zhang et al. (2025c) G. Zhang, Y. Yue, X. Sun, G. Wan, M. Yu, J. Fang, K. Wang, T. Chen, and D. Cheng G-Designer: architecting multi-agent communication topologies via graph neural networks. In Proceedings of the 42nd International Conference on Machine Learning, Proceedings of Machine Learning Research, Vol. 267, p. 76678–76692. External Links: Link Cited by: §1, §2, §4.1. Zhang et al. (2025d) J. Zhang, J. Xiang, Z. Yu, F. Teng, X. Chen, J. Chen, M. Zhuge, X. Cheng, S. Hong, J. Wang, B. Zheng, B. Liu, Y. Luo, and C. Wu AFlow: automating agentic workflow generation. In The Thirteenth International Conference on Learning Representations, External Links: 2410.10762, Link Cited by: §1, §2, §4.1. Zhang et al. (2024) K. Zhang, J. Li, G. Li, X. Shi, and Z. Jin CodeAgent: enhancing code generation with tool-integrated agent systems for real-world repo-level coding challenges. arXiv preprint arXiv:2401.07339. External Links: 2401.07339, Document, Link Cited by: §1. Zhang et al. (2026) M. Zhang, W. Liu, T. Shen, Q. Lin, R. Mao, E. Cambria, X. Tang, and H. Luo FlowSteer: towards agents designing agentic workflows via reinforced progressive canvas editing. arXiv preprint arXiv:2602.01664. External Links: 2602.01664, Document, Link Cited by: §2. Zhou et al. (2026) H. Zhou, X. Wan, R. Sun, H. Palangi, S. Iqbal, I. Vulić, A. Korhonen, and S. Ö. Arık Multi-agent design: optimizing agents with better prompts and topologies. In The Fourteenth International Conference on Learning Representations, External Links: 2502.02533, Link Cited by: §2. Zhuge et al. (2024) M. Zhuge, W. Wang, L. Kirsch, F. Faccio, D. Khizbullin, and J. Schmidhuber GPTSwarm: language agents as optimizable graphs. In Proceedings of the 41st International Conference on Machine Learning, Proceedings of Machine Learning Research, Vol. 235, p. 62743–62767. External Links: Link Cited by: §1, §2.