AgentConductor: Topology Evolution for Multi-Agent Competition-Level Code Generation

Abstract: LLM(LLM)-driven multi-agent systems(MAS) coordinate specialized agents through predefined interaction topologies and have shown promise for complex tasks such as competition-level code generation. Recent studies demonstrate that carefully designed multi-agent workflows and communication graphs can significantly improve code generation performance by leveraging collaborative reasoning. However, existing methods neither adapt topology density to task difficulty nor iteratively refine the topology within an instance using execution feedback, which leads to redundant communication and performance bottlenecks. To address these issues, we propose AgentConductor: a reinforcement learning-optimized MAS with an LLM-based orchestrator agent as its core, which enables end-to-end feedback-driven dynamic generation of interaction topologies. For each query, AgentConductor infers agent roles and task difficulty, then constructs a task-adapted, density-aware layered directed acyclic graph (DAG) topology, underpinned by two key innovations. First, we design a novel topological density function that captures communication-aware mathematical characterizations of multi-agent interactions. Second, we adopt difficulty interval partitioning to avoid excessive pruning for precise topological density upper bound measurement per difficulty level and finer-grained control. Empirically, across three competition-level and two foundational code datasets, AgentConductor achieves state-of-the-art accuracy, outperforming the strongest baseline by up to 14.6% in pass@1 accuracy, 13% in density reduction, and 68% in token cost reduction.

• The paper demonstrates a novel reinforcement learning-optimized orchestrator that generates layered DAG topologies for multi-agent code generation.
• It introduces a formal topology density metric combining node count, edge density, and graph depth to balance computational cost with code accuracy.
• Empirical evaluations reveal significant accuracy improvements and token consumption reduction across diverse competitive programming benchmarks.

Topology Evolution for Multi-Agent Competition-Level Code Generation: AgentConductor

Introduction

The paper "AgentConductor: Topology Evolution for Multi-Agent Competition-Level Code Generation" (2602.17100) introduces an LLM-driven multi-agent system (MAS) designed to dynamically generate and refine interaction topologies for code generation in competition-level programming tasks. It addresses the limitations of fixed and query-conditioned interaction graphs found in previous MAS approaches, establishing a reinforcement learning (RL)-optimized orchestrator at the system’s core. The orchestrator infers agent roles and task difficulty to instantiate a difficulty-aware, layered DAG topology, which is iteratively evolved in response to execution feedback for each code generation instance. The paper details contributions in the formalization of topology density, reward design, and empirical validation across several code generation benchmarks.

Methodology

Dynamic Topology Generation

AgentConductor departs from both the fixed-topology paradigm and the static query-conditioned topology generation. The orchestrator agent, implemented as a fine-tuned LLM, estimates task difficulty and devises layered DAG interaction topologies that scale density to difficulty. This topology supports intra-layer parallelism and cross-layer communication, directly encoded in YAML for both human interpretability and agent operability. During multi-turn code generation, execution feedback is consumed to iteratively refine the topology, ensuring adaptivity and minimizing redundant communications.

Topological Density Formalization

The paper introduces a complexity evaluation function, $S_{\text{complex}}$, combining normalized measurements of nodes, edge density, and graph depth:

%%%%1%%%%

where $|V|$ and $|E|$ denote the number of nodes and edges, $d$ is graph depth, and $N_{\max}(l)$ is a difficulty-dependent cap. This metric provides a principled proxy for interaction cost and enables explicit reward shaping within RL.

Reinforcement Learning Paradigm

The orchestrator is initially trained with supervised fine-tuning (SFT) on a curated corpus spanning problem difficulties and agent compositions, instilling structural priors. Subsequently, RL using Group Relative Policy Optimization (GRPO) optimizes the policy to generate effective topologies in multi-turn interaction with a sandboxed execution environment. The trajectory-level reward incorporates code correctness, topology validity, and density regularization, supporting fine-grained trade-off between cost and accuracy.

Experimental Results

Empirical evaluation spans three competition-level datasets (APPS, LiveCodeBench v4, CodeContests) and two foundational datasets (HumanEval, MBPP). AgentConductor achieves state-of-the-art pass@1 accuracy:

• APPS: 58.8%, a 14.6% absolute increase over the strongest topology optimization baseline
• LiveCodeBench v4: 46.3% (+3.1%)
• CodeContests: 38.8% (+1.1%)
• HumanEval: 97.5% (+1.0%)
• MBPP: 95.1% (+0.7%)

The method demonstrates substantial gains in both topology density reduction (up to 13%) and token consumption (up to 68%) while maintaining or improving accuracy, confirming the efficacy of iterative, feedback-driven topology adaptation. Ablation studies validate the necessity of both SFT and RL stages, and the impact of individual reward terms on code performance and topology validity.

Furthermore, density adaptation is evidenced: easy instances invoke sparser topologies, while difficult cases admit denser and deeper interaction graphs—contrasted against baseline systems that display little or no density modulation across task difficulty. The orchestrator’s zero-shot transfer capability to new agent roles and problem domains is verified, maintaining practical viability beyond code synthesis.

Theoretical and Practical Implications

AgentConductor formalizes cost-efficient multi-agent orchestration with topology density as a control variable, contributing a mathematically-grounded metric for balancing operational cost and solution accuracy. The approach demonstrates that difficulty-aware, feedback-driven topology modulation—rather than monotonic sparsity or rigid agent compositions—enables scalable MAS for challenging programming tasks.

Practically, the modular topology YAML encoding, alongside its RL-powered generation, supports flexible deployment and human interpretability. Cross-domain transfer experiments imply general applicability to multi-hop reasoning and agent-based QA, underscoring potential for broader MAS orchestration in AI systems.

Future Directions

The results motivate further development in dynamic MAS orchestration, with open avenues including:

• Scalability to larger agent pools and more granular difficulty calibration
• Integration of richer execution environments and external tools
• Expansion to broader reasoning and problem-solving domains in AI
• Exploration of alternative reward shaping strategies and topology representations

Direct policy optimization over graph structures and iterative topology evolution suggest promising directions in adaptive multi-agent coordination, advancing both theoretical understanding and practical efficacy of agentic LLMs.

Conclusion

AgentConductor establishes an RL-driven MAS paradigm for competition-level code generation, achieving fine-grained, task-adaptive interaction topology evolution. By combining structured prior knowledge, formal density metrics, and feedback-driven policy optimization, the framework delivers superior accuracy and cost efficiency, contributing significantly to adaptive multi-agent orchestration and laying groundwork for advancing collaborative AI systems.