WorksComputer Science
DynaFlow: Learning Free-Form Multi-Agent Orchestration
Abstract
Multi-agent systems often rely on predefined collaboration structures, limiting their ability to adapt to diverse task requirements. We introduce DynaFlow, a framework that integrates free-form executable workflow synthesis into the action space of the main agent. The agent decides when collaboration is needed and generates task-specific programs that coordinate sub-agents through sequential or parallel execution, structured information exchange, and verification. Execution results and traces inform subsequent actions, enabling the agent to adapt collaboration as reasoning progresses. We train only the main agent through supervised fine-tuning on distilled trajectories, followed by refinement on examples filtered for unsupported premises, biased verification, and information-flow defects. All sub-agents remain fixed, separating orchestration learning from executor capability improvement. Across six benchmarks spanning mathematical reasoning, scientific question answering, and multi-hop retrieval, DynaFlow achieves 88.08% overall accuracy in Forced mode, outperforming the strongest evaluated baseline by 10.90 percentage points with the same Qwen3.5-27B backbone. Workflow analysis finds more explicit use, verification, and refinement of upstream outputs after training, highlighting cross-stage information flow as a key dimension of multi-agent orchestration.
Introduction
The effectiveness of multi-agent systems (MAS) built on large language models (LLMs) depends on how collaboration is organized. Many systems rely on fixed collaboration structures with pre-designed agent roles, communication patterns, or workflow components ([17, 13, 5] (Wu et al. 2024)). Yet coordination
requirements vary across tasks: simple queries may need only one agent, independent subtasks can benefit from parallel execution, and dependent stages require reliable access to upstream results. Applying a fixed collaboration structure across these settings can introduce unnecessary communication, latency, and computation ([18, 20] (Yin et al. 2026)). We argue that scalable MAS require a stronger capability, which we refer to as Free Orchestration: the ability to decide when collaboration is useful and construct task-specific workflows during problem solving.
Automated workflow design has begun to address this rigidity. Existing approaches search for effective workflows using execution feedback (Zhang et al., 2025c), or generate and adapt query-specific agent systems during inference ([12, 34, 38, 15, 14] (Ye et al. 2025)). However, these advances retain constraints on workflow construction and adaptation. DyFlow revises plans using execution feedback but constructs them from a finite set of operator templates ([38]). MAS-Orchestra formulates orchestration through function calls, yet generates the complete coordination structure in a single decision without observing intermediate execution results [14]. These limitations motivate combining free-form workflow synthesis with repeated orchestration decisions informed by execution feedback. We therefore investigate executable workflow synthesis as a native action of the task-solving agent, alongside ordinary tool use. The same agent decides (i) when to collaborate, (ii) constructs task-specific programs, and (iii) uses their returned outputs and traces to determine how to proceed.
To this end, we introduce DynaFlow (Figure 2), a framework that integrates free-form executable workflow synthesis into the task-solving agent’s action space. We refer to this agent as the main agent, which coordinates sub-agents responsible for executing delegated subtasks. The Main Agent can answer directly, use ordinary tools, or generate a task-specific workflow program. Through a minimal execution interface, it defines sub-agent responsibilities, sequential or parallel dependencies, and how intermediate outputs are passed, aggregated, and verified directly in code. A budget-constrained runtime executes the program and returns its outputs and execution trace. The Main Agent then uses this feedback to guide subsequent actions, including synthesizing follow-up workflows that adapt collaboration to the observed results.
Figure 2. Overview of DynaFlow. (1) Two-stage SFT trains only the Main Agent on first-turn reasoning and workflow action , using distilled demonstrations followed by a curated subset. (2) It chooses to answer directly, call a tool, or generate a JavaScript workflow. (3) Frozen sub-agents collaborate within the workflow according to the Main Agent’s program. (4) Outputs and execution traces update the history for subsequent decisions.
We decouple orchestration learning from sub-agent training by updating only the Main Agent on distilled workflow demonstrations while keeping all sub-agents fixed. This focuses learning on coordinating existing capabilities and allows pre-trained models to be reused as executors without retraining. The training process begins with distilled workflow demonstrations. Since answer correctness alone does not guarantee reliable coordination, we then refine the policy on a curated subset that excludes demonstrations flagged for unsupported premises, biased verification, or incomplete information transfer. This training process makes orchestration quality an explicit criterion for selecting demonstrations, guiding the Main Agent toward more reliable task coordination and information use.
Across six benchmarks spanning mathematical reasoning, scientific question answering, and multi-hop retrieval, DynaFlow achieves 88.08% overall accuracy in Forced mode, exceeding the strongest evaluated baseline using the same backbone by 10.90 percentage points. In Dynamic mode, it maintains accuracy close to Forced execution while answering 47.1% of questions without invoking a workflow. Further analysis finds that training leads to more explicit use, verification, and refinement of upstream outputs. Together, these results support learning both how to organize collaboration and when to invoke it, and identify cross-stage information use as a key dimension of effective orchestration.
Related Work
Agentic Workflows and Orchestration. A workflow specifies model and tool calls through instructions, control flow, and information dependencies. Control flow determines execution order and branching, while data flow specifies which intermediate outputs later calls receive. Orchestration organizes these calls to solve a task. AutoGen provides programmable agent interactions, while Magentic-One and Apodex 1.1 support runtime coordination and replanning ([11, 2] (Wu et al. 2024)). Graph- and code-based representations support automated workflow design ((Zhuge et al., 2024; Zhang et al., 2025c)), and executable code can express tool-use actions and orchestration logic ([36, 26]). These advances provide expressive mechanisms for collaboration, while verification-centered systems emphasize checking intermediate decisions and their supporting evidence ([1, 25]). We therefore focus on learning when to invoke collaboration and how to construct task-specific workflows that preserve, check, and reuse intermediate results. We further examine how training changes workflow patterns, focusing on stage dependencies and the use, verification, and refinement of intermediate results. Comparing these changes alongside design quality and task accuracy helps characterize the properties of effective orchestration and their relationship to improved performance (Figure 5 and Figure 4; § 5.3).
Figure 4. Workflow design quality. Judge scores for the first workflow generated for each question in Forced mode across all benchmarks: 0 = major defect, 1 = minor weakness, and 2 = no defect.
Figure 5. Workflow structure and information use across stages. Distributions (%) of six properties of workflow programs generated under Forced execution: (a) execution structure, (b) role specialization, (c) dependency pattern, (d) output reuse, (e) aggregation strategy, and (f) sub-agent count. Definitions are provided in Table 5.
Learning Task-Specific Orchestration. Task-specific orchestration raises two related questions: how to learn workflow generation and how to adapt designs using execution feedback, a mechanism also studied in agent–environment interaction and strategy-guided exploration ([24, 20]). MAS-GPT learns query-specific system generation through supervised training, while FlowReasoner and Mas-Orchestra use reinforcement learning ([12, 14] (Ye et al. 2025)). MAS-Zero revises system designs using intermediate results, and DyFlow plans successive subgraphs using feedback ([15, 38]). FlowSteer learns graph-editing policies from canvas feedback ((Zhang et al., 2026a)). MetaAgent-X further jointly trains designers and executors ((Zhang et al., 2026c)). DynaFlow integrates free-form executable workflow actions into the task-solving policy, coupling collaboration decisions with workflow construction and subsequent decisions based on execution feedback. Its learning framework explicitly selects demonstrations for orchestration quality and trains only the Main Agent, emphasizing reliable information transfer and independent verification with fixed sub-agents.
DynaFlow
DynaFlow integrates free-form executable workflow synthesis into the Main Agent’s action space. The Main Agent selects whether and how to collaborate, while workflow outputs and execution traces inform subsequent decisions (Figure 2). We formalize this decision process before describing orchestration learning with fixed sub-agents.
Free-Form Workflow Orchestration
Given a question and task instruction , the Main Agent follows a policy over three action forms:
where is the set of ordinary tool-call actions, denotes a final-answer output action, and denotes a single workflow action comprising both the JavaScript program synthesized by the Main Agent and its invocation through the workflow tool . Answer content and arguments for ordinary tools are generated with the corresponding actions and left implicit in the notation. At turn , the Main Agent generates , where is the ordered history of previous actions and observations. The same policy therefore decides whether to answer, use a tool, or construct and invoke a workflow in light of the task and available feedback.
We evaluate this policy under two execution modes. In Dynamic mode, the first decision selects between a direct answer and a workflow call; in Forced mode, the first substantive action must invoke a workflow. Forced execution evaluates workflow construction without the initial routing decision. Both modes allow subsequent tool calls and follow-up workflows. Once a workflow is invoked, the Main Agent is restricted to coordination and summarization, with substantive problem solving delegated to sub-agents.
The program defines sub-agent roles, stages, and dependencies through agent calls, parallel execution, and optional phase labels. Independent calls can run concurrently, while dependent calls receive upstream outputs explicitly. Each sub-agent receives only the instructions and inputs specified by . The workflow tool executes with fixed sub-agents under resource constraints, returning an observation that combines the program output with an execution trace recording the status and output of each sub-agent call (Figure 2, panel 3; Appendix § 9).
After receiving , the Main Agent appends to the history to obtain and generates its next action conditioned on , , and . When it judges the available information sufficient to answer , it emits and terminates; otherwise, it invokes a tool or workflow to verify, refine, or extend the available results (Figure 2, panel 4). Algorithm 1 summarizes this feedback loop over the action space in Eq. (1).
Learning the Orchestration Policy
Building on the action formulation in § 3.1, we train the Main Agent policy to construct task-specific workflows and coordinate information flow across sub-agents. Training proceeds in two stages, updating only the Main Agent while keeping all sub-agents fixed (Figure 2, panel 1).
Stage 1: trajectory distillation. A teacher model generates trajectories using the same workflow interface, tools, and fixed sub-agents. We retain trajectories with correct final answers that follow the delegation protocol in § 3.1, with substantive solving performed inside workflows. The supervised target is the Main Agent’s first-turn output, where is its reasoning and is the workflow action defined in § 3.1. This yields a dataset of examples . Both training stages minimize
with in Stage 1 and the curated subset in Stage 2. The loss supervises both the reasoning tokens in and the action tokens in ; instructions, questions, and tool definitions are masked. Supervision thus targets first-turn task analysis and workflow synthesis.
Stage 2: high-quality data selection. Stage 1 demonstrations meet the final-answer correctness and execution-protocol criteria while varying in orchestration quality. Evaluation of the Stage 1 model reveals that failures in information transfer and incorrect Main Agent judgments can steer workflows toward wrong answers. These observations motivate selecting high-quality demonstrations that support reliable information transfer and independent problem solving within workflows, with the aim of improving the Main Agent’s orchestration capability.
Given each question and program , an LLM judge assesses orchestration quality by checking for three types of defects: (i) premise injection, where the Main Agent presents answer-determining claims beyond the task givens as established premises; (ii) verification defects, where review instructions or output constraints steer a verifier toward an expected answer or restrict independent checking and revision; and (iii) information-flow defects, where missing context, incorrect references, lossy transfer, or hard-coded substitutes for upstream outputs prevent required information from reaching downstream agents. Verification is assessed only when a reviewing step is present. Each reported defect must be supported by matching excerpts from the program or its launch arguments. We retain complete first-turn examples accepted after this evidence check. The judging rubric and agreement with manual annotation are described in Appendix § 12. Denoting this selection procedure by , we obtain
Stage 2 continues from the Stage 1 checkpoint on with the same objective and a smaller learning rate. An equal-size random-subset continuation control is required to distinguish curation effects from additional training (§ 4). Training data and hyperparameters are detailed in § 4 and Appendix § 10.
Experimental Setup
Our experiments examine whether training the Main Agent improves workflow-based problem solving, how high-quality data selection affects orchestration, and whether adaptive workflow invocation preserves performance while reducing workflow use. Throughout the DynaFlow comparisons, sub-agents remain fixed, allowing us to study changes in the Main Agent under a shared workflow interface and tool configuration.
Benchmarks and models. We evaluate on 688 questions across six benchmark sets: AIME 2024, 2025, and 2026, PolyMATH (Wang et al., [39]) (200), GPQA-Diamond (Rein et al., [29]) (198), and HotpotQA (Yang et al., 2018) (200). The PolyMATH and HotpotQA subsets are sampled with random seed 42. These benchmarks cover competition mathematics, multilingual mathematical reasoning, scientific reasoning, and multi-hop question answering. HotpotQA uses web search for retrieval. The Main Agent uses Qwen3.5-27B (Qwen Team, [28]) as its backbone. Across all DynaFlow evaluation settings, workflow sub-agents uniformly use the Base Qwen3.5-27B checkpoint without orchestration training and remain fixed. Both the Main Agent and sub-agents operate with thinking enabled; only the Main Agent receives orchestration training.
Training and evaluation settings. We compare three Main Agent checkpoints: Base, the backbone without orchestration training; Stage 1, trained by trajectory distillation; and DynaFlow, obtained after Stage 2 training on selected high-quality demonstrations. We use GLM-5.3 Max as the teacher model for trajectory distillation. Stage 1 uses QLoRA (Dettmers et al., [7]) to fine-tune the Main Agent on 2,257 teacher-distilled first-turn examples; Stage 2 continues on 712 selected examples under Eq. (2).
The evaluation includes three execution modes: Direct answers without tools or workflows; Dynamic chooses between direct answering and workflow execution; and Forced requires workflow execution before any substantive problem solving. In both workflow-based paths, the Main Agent is restricted to designing and coordinating workflows, assessing returned results, and synthesizing the final answer; substantive solving and verification are delegated to sub-agents. Incomplete results trigger workflow revision or further calls (§ 3.1).
Baselines and metrics. We compare against CoT, CoT-SC (Wang et al., [37]), Self-Refine (Madaan et al., [23]), and AFlow (Zhang et al., 2025c), all using Qwen3.5-27B. CoT-SC aggregates five sampled answers, while Self-Refine iteratively critiques and revises an answer. For AFlow, we transfer the released MATH workflow to AIME and PolyMATH, and the released HotpotQA workflow to HotpotQA and GPQA-Diamond, without searching for new workflows on our evaluation tasks. We also include Base + Web search to contextualize gains on retrieval-dependent questions. The tool-free baselines do not have the same retrieval access as the workflow settings; we therefore interpret their HotpotQA results separately from comparisons with search-enabled systems.
We report final-answer accuracy, counting runs without a valid final answer as incorrect. To examine orchestration behavior, we analyze Forced-mode workflows using structural indicators and four design criteria: task consistency, decomposition appropriateness, logical continuity, and information-flow correctness. Design scores range from 0 (major defect) through 1 (minor weakness) to 2 (no defect).
Results and Analysis
Overall Performance
DynaFlow achieves the highest overall accuracy, reaching 88.08% in Forced mode and 87.94% in Dynamic mode (Table 1). Both exceed the strongest baseline by over 10 percentage points and outperform their Base counterparts, with only the Main Agent trained and all sub-agents fixed.
| Method | AIME24 | AIME25 | AIME26 | PolyMATH | GPQA-D | HotpotQA | Overall |
| Single-agent baselines | |||||||
| CoT | 96.67 | 93.33 | 86.67 | 83.00 | 85.35 | 46.50 | 74.27 |
| CoT-SC | 90.00 | 93.33 | 96.67 | 84.50 | 85.86 | 50.50 | 76.16 |
| Self-Refine | 96.67 | 93.33 | 93.33 | 87.50 | 88.38 | 48.00 | 77.18 |
| Automated multi-agent baseline | |||||||
| AFlow | 93.33 | 96.67 | 100.00 | 86.00 | 87.37 | 47.00 | 76.45 |
| Untrained Main Agent | |||||||
| Base, Direct | 93.33 | 93.33 | 93.33 | 74.00 | 83.33 | 47.50 | 71.51 |
| Base + Web search | 83.33 | 73.33 | 73.33 | 66.00 | 79.80 | 77.50 | 74.71 |
| Base, Dynamic | 63.33 | 63.33 | 73.33 | 64.00 | 77.78 | 53.00 | 65.12 |
| Base, Forced | 76.67 | 70.00 | 70.00 | 70.00 | 77.78 | 81.50 | 75.87 |
| Trained Main Agent (ours) | |||||||
| DynaFlow (Direct) | 93.33 | 90.00 | 90.00 | 87.00 | 86.87 | 51.50 | 77.18 |
| DynaFlow (Dynamic) | 93.33 | 100.00 | 96.67 | 91.50 | 83.84 | 84.50 | 87.94 |
| DynaFlow (Forced) | 100.00 | 100.00 | 100.00 | 90.50 | 84.85 | 83.50 | 88.08 |
Table 1. Main results. Accuracy (%) on six benchmarks. All systems use Qwen3.5-27B, and all workflow settings share the same frozen sub-agents and runtime. Overall is micro-averaged over all 688 questions. Runs that end without a valid final answer count as incorrect. Bold and underline mark the best and second-best result in each column. with the single-agent baselines (§ 5.1).
Mathematical reasoning. DynaFlow achieves the strongest results across competition and multilingual mathematics. Forced execution solves all 90 AIME questions, achieving 100% across the 2024, 2025, and 2026 sets, while both modes exceed the strongest baseline on PolyMATH by 3–4 percentage points. We analyze the generated workflows and find that they organize mathematical solving around complementary derivation, computation, and verification stages. For example, PolyMATH
workflows pair symbolic derivations with small-instance numerical checks to identify errors in intermediate expressions. This integration offers a concrete explanation for the strong mathematical performance: intermediate results are exposed to checks that can guide subsequent correction.
Scientific knowledge and reasoning. DynaFlow improves performance on GPQA-Diamond, which covers graduate-level questions in biology, chemistry, and physics. Forced execution reaches 84.85%, improving over Base, Forced by 7.07 points and exceeding Base, Direct; Dynamic execution also improves over its Base counterpart. With the sub-agents fixed, we obtain stronger scientific question answering through Main Agent training, although Self-Refine and AFlow remain ahead on this benchmark. We examine failed cases and find that incorrect intermediate conclusions from sub-agents can misguide subsequent verification, while the Main Agent can fail to prioritize correct evidence when synthesizing the final answer. These failures highlight the importance of independent verification within workflows and reliable final-answer selection by the Main Agent.
Multi-hop question answering with web search. DynaFlow achieves the best HotpotQA performance, reaching 84.50% in Dynamic mode and 83.50% in Forced mode. Both exceed Base + Web search by 6–7 points, and Forced execution also improves over Base, Forced under the same workflow requirement. We analyze the retrieval workflows and find that they organize search around intermediate entities and verify the connections between successive hops. For example, a workflow first identifies the city associated with a venue, then retrieves the city’s nickname and checks that both hops refer to the same entity. Such evidence-chain construction and verification provide a plausible account of the gains over a search-enabled baseline and illustrate how DynaFlow organizes retrieval into a coherent solving process.
Effect of Training and Execution Mode
We examine how training affects workflow-based solving under matched execution settings (Table 2; Figure 3). Base, Forced underperforms Base, Direct on every benchmark except HotpotQA, where workflows enable retrieval. After Stage 1, Forced execution reaches or exceeds the Base, Direct reference on all six benchmarks and surpasses Direct within the same checkpoint by 8.73 points overall, including retrieval gains on HotpotQA. We thus find that orchestration training turns workflow access into effective collaboration, yielding gains beyond the trained Main Agent’s standalone performance. This pattern is consistent with prior findings that collaboration benefits depend on task characteristics and coordination structure [16].

Figure 3. Workflows help only after training. Accuracy change in Forced mode relative to Base, Direct. Without training, workflows lower accuracy on every benchmark except HotpotQA; after training, Forced mode matches or exceeds Base, Direct on all six.
| Main Agent | Direct | Dynamic | Forced |
| Base | 71.51 | 65.12 | 75.87 |
| Stage 1 | 76.74 | 84.45 | 85.47 |
| DynaFlow (Stage 2) | 77.18 | 87.94 | 88.08 |
Table 2. Training stage execution mode. Overall accuracy (%). Only the Main Agent differs between rows. Per-benchmark results are in Table 6.
Stage 2 further improves both Forced and Dynamic performance. Our workflow analysis finds higher design quality and more frequent use and refinement of upstream results with fewer sub-agents on average than Stage 1 (Figure 4 and Figure 5; § 5.3), linking the performance gains to more focused coordination.
dependencies, whereas trained programs usually combine parallel and sequential stages. Hybrid workflows increase from 3.4% for Base to 83.2% after Stage 1 and 85.6% after Stage 2. The share of programs that pass upstream outputs and explicitly instruct downstream agents to use them rises from 12.6% for Base to 93.3% after Stage 1 and 97.7% after Stage 2 (Figure 5(d)). Training thus improves information use in workflow design: the Main Agent increasingly specifies how intermediate results should inform subsequent solving and verification, enabling systematic reuse across stages.
Higher-quality information flow and verification. Our analysis of Stage 1 errors identifies three recurring patterns: unsupported premises introduced by the Main Agent, verification guided toward an expected conclusion, and incomplete or incorrect transfer of intermediate information. These observations motivate selecting Stage 2 demonstrations that avoid premise injection, verification defects, and information-flow defects (§ 3.2). After training on the selected data, we find higher proportions of defect-free workflows across all four design criteria. Major information-flow defects decline from 1.9% in Stage 1 to 0.9% in Stage 2 (Figure 4), while workflows that specify correction or refinement of intermediate results increase from 28.1% to 35.9% (Figure 5(e)). These results indicate better workflow design for transferring, inte-
Workflow Quality and Task-Specific Organization
Connected stages and improved information use. Figure 5(a,Figure 5c) shows that Base typically delegates to a single sub-agent or constructs calls without grating, and checking intermediate results through explicit dependencies and structured information exchange, with fewer sub-agents on average (4.16 versus 4.35 in Stage 1). We interpret Base’s relatively high logical-continuity scores in light of its simpler, often single-agent workflows, which involve fewer dependencies between stages.
Task-specific roles and instructions. Figure 6 shows distinct role configurations across tasks. Solvers and verifiers account for over 90% of nodes on AIME and PolyMATH, while researchers account for 59.6% on HotpotQA. GPQA-Diamond combines a substantial solver component with more research than the mathematics benchmarks. Verification remains common across tasks, accounting for 33.2–43.9% of nodes. This task-specific organization extends to the instructions themselves: the Main Agent generates a prompt for each sub-agent that specifies its objective, relevant inputs, and use of upstream results for the current question (§ 3.1). DynaFlow thus adapts both the division of labor and the instructions that guide execution, connecting task decomposition with information use. Relative to the transferred AFlow workflows used in our evaluation (§ 4), this flexibility supports question-specific mathematical derivation, evidence gathering, and independent checking (§ 5.1).
Adaptive Workflow Invocation
The Dynamic–Forced accuracy gap narrows from 10.75 percentage points for Base to 1.02 after Stage 1 and 0.14 for DynaFlow (Table 2). With sub-agents fixed, this trend highlights the contribution of Main Agent training to selective collaboration. In Dynamic mode, DynaFlow answers 47.1% of questions directly while achieving 87.94% accuracy, close to 88.08% under Forced execution. Averaged over all questions, including those answered directly, it uses 2.44 sub-agents per question versus approximately 4.16 under Forced execution, a reduction of about 41% (Figure 1). These results suggest that a unified Main Agent policy can adapt its solution strategy to task requirements while maintaining performance with fewer sub-agents. We regard the choice between direct answering and workflow execution as an integral part of orchestration: additional agents do not necessarily improve performance, and collaboration should be invoked according to the needs of each question.
Figure 1. Overall accuracy versus collaboration size. Accuracy versus the mean number of agent roles per question on 688 questions (Qwen3.5-27B). In Forced mode, DynaFlow improves accuracy from Base’s 75.9% to 88.1%. Dynamic achieves 87.9% with 3.44 agent roles per question on average, while answering 47% of questions without workflows.
Discussion
We view reliable information use alongside task decomposition as central to orchestration; gains with fixed sub-agents support learning to coordinate existing capabilities (§ 5.2). Stage 2 gains accompany better information transfer and more frequent refinement of intermediate results, consistent with screening for unsupported premises, constrained verification, and information-flow defects (§ 5.3). Our analysis of GPQA-Diamond failures illustrates how correct intermediate results can be lost or overridden during verification and final synthesis. DynaFlow workflows incorporate complementary evidence gathering, independent checks, and refinement of intermediate results. Future work could train sub-agents for reliable information transfer and independent verification, and extend first-turn supervision to multi-turn trajectories containing disagreements and erroneous results. Such supervision could strengthen the Main Agent’s ability to independently assess conflicting outputs, identify errors, and select actions for error recovery, workflow revision, and final-answer selection.
Conclusion
DynaFlow combines free-form executable workflow actions with two-stage Main Agent training through trajectory distillation and demonstration selection based on orchestration quality, keeping sub-agents fixed. Across six benchmarks, it achieves the highest overall accuracy among evaluated methods; Dynamic execution answers nearly half the questions directly with accuracy close to Forced execution. Workflow analysis characterizes how training changes structure and the use of intermediate results.
Experimental Setup Details
Benchmarks. The evaluation contains 688 questions: 30 from each of AIME 2024, 2025, and 2026; 200 from PolyMATH; 198 from GPQA-Diamond; and 200 from HotpotQA. PolyMATH and HotpotQA are sampled with seed 42. AIME requires integer answers, PolyMATH includes multilingual mathematical questions with free-form answers, GPQA-Diamond uses multiple-choice scientific questions, and HotpotQA requires connecting evidence across retrieval steps.
Models and baselines. The Agent uses Qwen3.5-27B, and all workflow sub-agents use its Base checkpoint without orchestration training. Both operate with thinking enabled; only the Agent receives orchestration training. CoT, five-sample CoT-SC, Self-Refine, and AFlow use the same backbone. AFlow uses the released MATH workflow on AIME and PolyMATH and the released HotpotQA workflow on HotpotQA and GPQA-Diamond. These workflows are transferred without an additional workflow search on the evaluation tasks. Base + Web search provides a comparison with direct retrieval access.
Workflow Runtime
The Main Agent passes a JavaScript program to the Workflow tool. Programs define sub-agent instructions and pass intermediate outputs through ordinary code. The interface provides agent for sub-agent calls, parallel for concurrent calls, pipeline for dependent stages over multiple items, and phase for stage labels. A sub-agent receives the instruction and inputs specified by the program; the Main Agent’s interaction history is not automatically inherited. Calls may request structured outputs through a JSON schema. Workflow completion returns the program result together with execution information, which the Main Agent can use to revise the workflow or produce a final answer. During evaluation, Direct answers without tools, Dynamic selects between direct answering and workflow execution, and Forced requires workflow invocation before substantive problem solving. The corresponding prompts are provided in Appendix F.
Training Details
GLM-5.3 Max provides the teacher trajectories. The Stage 1 training set contains 2,257 first-turn demonstrations from HotpotQA and BrowseComp. Supervision covers the first-turn reasoning and action; instructions, questions, and tool definitions are masked from the loss. Only the Main Agent is fine-tuned, while all sub-agents remain fixed.
Stage 2 continues from the Stage 1 checkpoint on 712 complete workflow demonstrations selected from the Stage 1 training set: 449 from HotpotQA and 263 from BrowseComp. Both stages train for two epochs using the objective in Eq. (2), with a smaller learning rate in Stage 2 and no separate validation split. Table 3 summarizes the training configuration, and Appendix § 12 describes data selection.
| Parameter | Stage 1 | Stage 2 |
| Training examples | 2,257 | 712 |
| Learning rate | ||
| Epochs | 2 | 2 |
| LoRA rank / / dropout | 16 / 32 / 0 | |
| Optimizer | Fused AdamW | |
| Schedule / warmup ratio | Cosine / 0.05 | |
| Effective batch size | 4 | |
| Max sequence length | 67,584 | |
| Random seed | 42 |
Table 3. Table 3: Training configuration. Only the Main Agent is updated. Shared values apply to both stages; maximum sequence length denotes the configured upper limit.
We use ms-swift 4.6.0.dev0 for training with 4-bit NF4 QLoRA, double quantization, BF16 computation, and gradient checkpointing. The Qwen3.5-27B backbone has approximately 27 billion parameters, with 116,727,808 trainable parameters in our configuration. LoRA targets eligible linear layers through all-1-linear, while the visual encoder and alignment module remain frozen. Each stage runs on two NVIDIA H100 80GB GPUs, with a single training process sharding the model across both devices. Based on full job wall-clock time, Stage 1 and Stage 2 consume about 52 and 17 GPU-hours, respectively, totaling about 69 GPU-hours. This budget covers fine-tuning only, excluding teacher trajectory generation, evaluation, and LLM-based judging.
Evaluation Protocol
Decoding configuration. Table 4 summarizes the decoding configuration for DynaFlow evaluation. Thinking is enabled for both the Main Agent and sub-agents. The output-token limits apply to individual model responses, rather than the number of workflow stages or interaction turns.
| Parameter | Value |
| Main Agent | |
| Context length | 131,072 |
| Max output tokens | 81,920 |
| Temperature / top- / top- | 1.0 / 0.95 / 20 |
| Presence penalty / seed | 1.5 / 42 |
| Sub-agents | |
| Max output tokens | 65,536 |
Table 4. Evaluation decoding parameters.
Answer scoring. For DynaFlow, the prediction is extracted from the Main Agent’s final FINAL ANSWER line; intermediate reasoning and sub-agent outputs are not substituted for an absent final answer. Runs without a valid final answer are counted as incorrect. AIME answers are matched as integers after normalizing leading zeros, and GPQA-Diamond answers are matched to the question’s option labels. PolyMATH permits exact mathematical equivalence, while HotpotQA accepts answers that identify the reference entity or relation, including equivalent names and aliases. Approximate decimals are not accepted as exact answers when the task specifies no numerical precision.
Workflow quality and structure. Workflow programs generated in Forced mode are evaluated by deepseek-flash ([6]) with thinking enabled, high reasoning effort, and temperature 0, using the question and program without execution results. Task consistency, decomposition appropriateness, logical continuity, and information-flow correctness are scored as 0 (major defect), 1 (minor weakness), or 2 (no defect). Structurally inapplicable logical-continuity and information-flow ratings are mapped to 2 when no relevant dependencies are required; insufficient-evidence ratings are excluded. We characterize the workflow programs generated by the Main Agent along six structural dimensions (Table 5) and compare the distributions of these properties across training stages in Figure 5.
| Dimension | Categories and definitions |
| Execution structure | Code only: no agent reasoning node, only code or tools; Single agent: exactly one agent reasoning node; Serial: multiple agents operate mainly in sequence, with later stages depending on earlier ones; Parallel: agents operate mainly independently in parallel, without substantial sequential dependencies; Hybrid: parallel branches and sequential agent dependencies are meaningfully combined. |
| Role specialization | None: fewer than two agents; Homogeneous: agents mainly perform the same role or type of attempt; Complementary: agents differ in roles, perspectives, subtasks, or methods; Mixed: homogeneous attempts and complementary roles coexist. |
| Dependency pattern | None: no agent depends on another agent’s output; Chain: outputs mainly form a sequential chain; Fan-out: one upstream result feeds multiple downstream agents; Fan-in: one downstream agent combines multiple upstream results; Multi-stage: multiple dependency forms or sequential stages are combined. |
| Output reuse | None: no upstream output is passed downstream; Passed: an upstream output is supplied, but its meaningful use is not explicitly required; Consumed: the actual upstream output is supplied and the downstream instruction explicitly requires using, analyzing, comparing, refining, critiquing, or transforming it. |
| Aggregation strategy | None: no result aggregation; Concatenation: results are collected without substantive comparison or synthesis; Selection: one result or candidate is selected; Voting: results are combined by voting or majority agreement; Comparison: outputs are explicitly compared; Synthesis: outputs are integrated into a new answer or representation; Correction/refinement: an upstream result is reviewed and may be revised; Mixed: multiple substantive aggregation mechanisms are used. |
| Agent count | Number of distinct agent reasoning nodes explicitly instantiated in the program, excluding deterministic code, formatting, and simple tool calls. Counts are displayed as 0, 1, 2, 3, 4, and 5+ in Figure 5. |
Table 5. Workflow structure definitions. Six structural dimensions used to characterize the workflow programs generated by the Main Agent.
Role assignment. Figure 6 summarizes the roles of sub-agents executed in each DynaFlow, Forced run, excluding the Main Agent. Based on commonly occurring roles in the generated workflows, we define five broad categories: Verifier, Aggregator, Interpreter, Researcher, and Solver. Categories are assigned using keywords in node labels, with phase names as a fallback. When multiple categories match, the order above determines priority; unmatched nodes are labeled Other. The Aggregator category covers synthesis, merging, and adjudication. Role proportions are computed over executed sub-agent nodes, with results pooled across the AIME benchmarks.
Figure 6. Task-specific role allocation. Percentages of executed sub-agent nodes by role and benchmark family in DynaFlow’s Forced mode. The three AIME years are pooled; denotes question counts. Classification details are in Appendix § 11.
Orchestration Quality Selection
The selection judge is deepseek-flash, with thinking enabled, high reasoning effort, and temperature 0. It receives the question, the workflow program generated in the first turn, and any launch arguments, without the Main Agent’s reasoning, final answer, reference answer, or execution results. The rubric checks three defects: premise injection, where unsupported answer-relevant claims are supplied as established facts; verification defects, where instructions or output constraints favor an expected conclusion or prevent independent correction; and information-flow defects, where missing context, incorrect references, or substituted values prevent required information from reaching downstream agents.
The judge cites excerpts from the workflow program or launch arguments to support each reported defect. We verify these excerpts against the supplied text as part of the quality screening. From the 2,257 workflow-containing demonstrations, we retain 712 complete first-turn examples for Stage 2.
Evaluation Prompts and Workflow Interface
Figure 7a presents concise versions of the Direct, Dynamic, and Forced evaluation prompts, the shared answer format, and the Workflow tool interface. These prompts specify the conditions for workflow invocation, task delegation, and use of returned results. The Main Agent determines sub-agent roles, instructions, and workflow structure for each question. Repeated formatting instructions are omitted for brevity.

Direct: task prompt
You are a professional AI assistant. Solve the task using only the supplied information, your existing knowledge, and reasoning, without any task-solving tool calls.
This boundary applies from the beginning of the task and throughout execution, including search, web reading, and code execution. For attachments, use the file contents supplied with the task; report the limitation if required contents are unavailable.
Dynamic: task prompt
Before substantive problem solving, select one execution path:
DIRECT: Answer using the task information, existing knowledge, and reasoning, without task-solving tools.
WORKFLOW: Organize the solution through Workflow. Substantive research, calculations, code execution, and verification must occur within the Workflow.
Do not solve the task before selecting the path. If retrieval or another task-solving tool is needed, select WORKFLOW before the first such call. If DIRECT is initially selected but tools are later needed, switch to WORKFLOW first.
Forced: task prompt
Invoke Workflow before substantive problem solving, even when the task could be answered from existing knowledge. Research, calculations, code execution, reasoning, and verification must occur within the Workflow.
The Main Agent may only plan, launch, monitor, revise, assess returned results, and summarize the final answer. This includes the first reasoning turn: understand the task and design its execution, without independently deriving the answer or supplying sub-agents with a pre-solved answer.
A completion status alone is insufficient when required subtasks have not returned results. Treat the run as incomplete and revise or rerun the Workflow.
Shared task and answer format
The task supplies a question and task identifier, with optional attachment names or paths.
Before the final answer, output a record:
{"task_id": "<task_id>", "Final answer": "<final_answer>"}
If no task identifier is supplied, use an empty string.
Finish the response with:
FINAL ANSWER: [YOUR FINAL ANSWER]
Follow the answer format requested by the task and do not include explanations after this final line.
Workflow: delegation and tool interface
Task delegation. Provide the original task, relevant context, attachment paths, and output requirements. Design the Workflow for the current task, using sub-agents, parallelism, verification, and additional stages as appropriate. Read and follow the tool description and input schema before invocation.
Invocation. Supply a JavaScript program through script, or a stored program through scriptPath, with optional args. Each script begins with a literal meta object containing name and description; optional phases describe its stages. The tool starts execution in the background and returns a task identifier; a completion notification provides the program’s returned result.
Execution primitives. agent(prompt, options) launches a sub-agent and returns final text or a validated object when a JSON schema is supplied. parallel(thunks) runs calls concurrently and waits for their results. pipeline(items, stages...) processes each item through dependent stages without waiting for unrelated items. phase(title) labels a stage, and args exposes invocation inputs. Ordinary JavaScript passes and transforms intermediate outputs in an asynchronous context.
Result handling. Do not independently duplicate the Workflow’s problem solving in the Main Agent. If results are incomplete, uncertain, or contradicted by evidence, revise or rerun the Workflow. Answer only when the returned results are sufficient, and base the final answer on them. Report a failure if Workflow is unavailable or cannot complete.
Figure 7a. Evaluation prompts and Workflow interface. Abridged prompt excerpts for the three execution modes, the shared answer format, and the Workflow tool.
(a)
Full Results
Table 6 lists per-benchmark accuracy for each Main Agent and execution mode. Figure 5 provides the detailed structural distributions underlying the workflow analysis in § 5.3.
| Main Agent | Mode | AIME24 | AIME25 | AIME26 | PolyMATH | GPQA-D | HotpotQA | Overall |
| Base | Direct | 93.33 | 93.33 | 93.33 | 74.00 | 83.33 | 47.50 | 71.51 |
| Dynamic | 63.33 | 63.33 | 73.33 | 64.00 | 77.78 | 53.00 | 65.12 | |
| Forced | 76.67 | 70.00 | 70.00 | 70.00 | 77.78 | 81.50 | 75.87 | |
| Stage 1 | Direct | 93.33 | 96.67 | 90.00 | 87.50 | 87.88 | 47.50 | 76.74 |
| Dynamic | 96.67 | 100.00 | 93.33 | 88.50 | 82.83 | 76.50 | 84.45 | |
| Forced | 96.67 | 96.67 | 100.00 | 84.50 | 84.34 | 82.00 | 85.47 | |
| DynaFlow | Direct | 93.33 | 90.00 | 90.00 | 87.00 | 86.87 | 51.50 | 77.18 |
| Dynamic | 93.33 | 100.00 | 96.67 | 91.50 | 83.84 | 84.50 | 87.94 | |
| Forced | 100.00 | 100.00 | 100.00 | 90.50 | 84.85 | 83.50 | 88.08 |
Table 6. Results by training stage and execution mode. Per-benchmark accuracy (%) by Main Agent and execution mode. DynaFlow is Stage 1 followed by curated training (Stage 2). Shaded rows denote DynaFlow.
Case Studies of Workflow Changes
We compare selected Base and DynaFlow workflows under Forced execution with fixed sub-agents, complementing the analysis of information use and task-specific organization in § 5.3. Each diagram is reconstructed from the workflow program and execution record; captions specify the displayed invocation and distinguish executed calls from conditional branches.
Complementary computation and explicit verification. For the palindrome-counting problem from AIME 2026 (Figure 8), Base delegates to one solver, which returns 59 after an arithmetic error. DynaFlow assigns enumeration, dynamic programming, and inclusion–exclusion to parallel solvers, then passes their outputs to a verifier for comparison and independent recomputation. All three solvers and the verifier obtain 62. This case illustrates how complementary methods and explicit use of intermediate results support mathematical verification.
Figure 8. AIME 2026: palindrome counting. Base uses one solver; DynaFlow connects three complementary computations to a common verifier. The dashed retry branch was not triggered. Repeated input and result packaging is omitted.
Preserving research evidence for scientific adjudication. For the reaction-product question from GPQA-Diamond (Figure 9), Base runs two analyses sequentially without passing results between them. DynaFlow assigns four research calls to distinct chemical constraints and checks the candidate products for each reaction. Both checks challenge their initial candidates, and the decision agent receives the research evidence alongside the verification results. Preserving these complementary inputs enables final synthesis to account for both the proposed answers and the objections raised during verification.
Figure 9. GPQA-Diamond: reaction-product identification. The dotted Base edge denotes call order without a data dependency; the displayed Base program contains no explicit return statement. DynaFlow shows its second invocation, integrating research evidence and verification results before answer selection.
Connecting entity identification to subsequent retrieval. For the HotpotQA question requiring person identification and year retrieval (Figure 10), the displayed Base call searches for investment firms and their founding years. DynaFlow instead uses three search routes to identify candidate entities, deduplicates and ranks them, and passes their names, quotations, and sources to candidate-specific resolution agents. Subsequent checks assess the selected proposal. This organization connects retrieval steps through explicit intermediate entities and supporting evidence, as discussed in § 5.1.
Figure 10. HotpotQA: person identification and year retrieval. Base shows the first of three invocations. DynaFlow resolves two candidates under a top-three cap; starred calls lack valid structured outputs and are filtered out. For person candidates, resolution prompts prioritize birth-year retrieval.
Linking solution stages to audits and conditional repair. For the geometric optimization problem from AIME 2025 (Figure 11), the displayed Base invocation checks a supplied derivation and returns fixed numeric fields. DynaFlow connects geometric construction, parallel optimization, expression fitting, and independent audits. Optimizer outputs inform the fitted candidate, while audit findings determine whether to invoke a repair step. Together, these cases illustrate the observation in § 5.3: task-specific orchestration connects stages by specifying what agents receive, how they use it, and how their outputs guide subsequent work.
Figure 11. AIME 2025: geometric optimization. Base shows its second invocation; DynaFlow shows its first. The starred optimizer was excluded before fitting because it returned no valid output. Both audits confirmed the candidate, so the dashed conditional repair call was not executed.
Extended Related Work
Multi-Agent Collaboration and Orchestration. LLM-based multi-agent systems (MAS) have progressed from predefined role-based collaboration toward adaptive, task-specific orchestration. Early approaches establish structured interactions through specialized agents, communication protocols, and iterative reasoning [4, 27, 8, 35]. Recent methods further explore dynamic agent selection, communication topology optimization, and automatic workflow construction [22, 20] (Zhang et al. 2025b).
Similar principles of specialization and selective information integration have been explored in multimodal learning, including cross-spectral augmentation [33], modality-decoupled representations [9], sparse mixture-of-experts [10], attention-guided alignment [31], and dynamic cross-modal coordination [21].
Unlike approaches relying on predetermined collaboration structures, DynaFlow learns to synthesize executable workflows according to individual task requirements and adapt subsequent decisions using execution feedback.
Efficiency and Reliable Information Flow. Effective collaboration requires balancing reasoning quality, computational efficiency, and reliable information exchange. AgentPrune reduces redundant communication (Zhang et al., 2025a), while broader MAS efficiency studies investigate topology optimization and resource allocation [20]. Meanwhile, analyses of multi-agent failures highlight challenges involving task decomposition, information propagation, and verification [3].
Related research has explored robust information selection through saliency-guided transfer [32], semantic label verification (Zhang et al., 2025d), uncertainty-guided expert selection (Zhang et al., 2025e), and generalization-preserving or collaborative continual learning (Zhang et al., 2025f, 2026b). Reliable evidence integration and structured information dependencies also arise in multimodal hallucination mitigation [30], dense video correspondence (Wu et al., 2026), and constrained visual generation (Wu et al., 2025).
These studies highlight complementary aspects of information selection, coordination, and reliability. DynaFlow addresses these challenges at the agent-workflow level by selectively invoking collaboration, explicitly organizing dependencies, and training the Main Agent on demonstrations filtered for orchestration quality.
Positioning of DynaFlow. DynaFlow unifies task-specific workflow synthesis, adaptive collaboration decisions, and feedback-driven orchestration within a single policy. Unlike methods that optimize fixed workflows or separately train multiple agents, DynaFlow updates only the Main Agent while keeping sub-agents fixed. Its emphasis on explicit information transfer and independent verification enables flexible collaboration tailored to individual tasks.
References
- [1]Apodex Team. 2026a. Apodex-1.0: A verification-centric agent team for discoverative intelligence. Technical report, Apodex.
- [2]Apodex Team. 2026b. Apodex 1.1: Scaling agentic intelligence for complex work. Preprint, arXiv:2608.23283.
- [3]Mert Cemri, Melissa Z. Pan, Shuyi Yang, Lakshya A. Agrawal, Bhavya Chopra, Rishabh Tiwari, Kurt Keutzer, Aditya Parameswaran, Dan Klein, Kannan Ramchandran, Matei A. Zaharia, Joseph E. Gonzalez, and Ion Stoica. 2025. Why do multi-agent llm systems fail? In Advances in Neural Information Processing Systems, volume 38.arxiv.org/abs/2503.13657
- [4]Weize Chen, Yusheng Su, Jingwei Zuo, Cheng Yang, Chenfei Yuan, Chi-Min Chan, Heyang Yu, Yaxi Lu, Yi-Hsin Hung, Chen Qian, et al. 2024. Agentverse: Facilitating multi-agent collaboration and exploring emergent behaviors. In International Conference on Learning Representations.arxiv.org/abs/2308.10848
- [5]Phuong Tuan Dat, Qi Li, and Xinchao Wang. 2026. Prism: Privileged sibling-guided multi-agent topology design. arXiv preprint arXiv:2610.20628.arxiv.org/abs/2610.20628
- [6]DeepSeek-AI. 2026. DeepSeek-V4.1-Flash: Pushing the limits of KV cache compression. Official model card. Accessed 2026-10-12.arxiv.org/abs/2609.19969
- [7]Tim Dettmers, Artidoro Pagnoni, Ari Holtzman, and Luke Zettlemoyer. 2023. QLoRA: Efficient fine-tuning of quantized LLMs. In Advances in Neural Information Processing Systems, volume 36, pages 10088–10115. Curran Associates, Inc.
- [8]Yilun Du, Shuang Li, Antonio Torralba, Joshua B. Tenenbaum, and Igor Mordatch. 2024. Improving factuality and reasoning in language models through multiagent debate. In International Conference on Machine Learning, volume 235, pages 11733–11763. PMLR.arxiv.org/abs/2305.14325
- [9]Yingying Feng, Jie Li, Jie Hu, Yukang Zhang, Lei Tan, and Jiayi Ji. 2025a. Mdreid: Modality-decoupled learning for any-to-any multi-modal object re-identification. Advances in Neural Information Processing Systems, 38:42584–42605.
- [10]Yingying Feng, Jie Li, Chi Xie, Lei Tan, and Jiayi Ji. 2025b. Multi-modal object re-identification via sparse mixture-of-experts. In International Conference on Machine Learning, pages 16796–16807. PMLR.
- [11]Adam Fourney, Gagan Bansal, Hussein Mozannar, Cheng Tan, Eduardo Salinas, Erkang Zhu, Friederike Niedtner, Grace Proebsting, Griffin Bassman, Jack Gerrits, Jacob Alber, Peter Chang, Ricky Loynd, Robert West, Victor Dibia, Ahmed Awadallah, Ece Kamar, Rafah Hosn, and Saleema Amershi. 2024. Magentic-One: A generalist multi-agent system for solving complex tasks. arXiv preprint arXiv:2411.04468.arxiv.org/abs/2411.04468
- [12]Hongcheng Gao, Yue Liu, Yufei He, Longxu Dou, Chao Du, Zhijie Deng, Bryan Hooi, Min Lin, and Tianyu Pang. 2025. FlowReasoner: Reinforcing query-level meta-agents. arXiv preprint arXiv:2504.15257.arxiv.org/abs/2504.15257
- [13]Sirui Hong, Mingchen Zhuge, Jonathan Chen, Xiawu Zheng, Yuheng Cheng, Jinlin Wang, Ce yao Zhang, Zili Wang, Steven Yau, Zijuan Lin, Liyang Zhou, Chenyu Ran, Lingfeng Xiao, Chenglin Wu, and Jürgen Schmidhuber. 2024. MetaGPT: Meta programming for a multi-agent collaborative framework. In The Twelfth International Conference on Learning Representations.arxiv.org/abs/2308.00352
- [14]Zixuan Ke, Yifei Ming, Austin Xu, Ryan Chin, Xuan-Phi Nguyen, Prathyusha Jwalapuram, Jiayu Wang, Semih Yavuz, Caiming Xiong, and Shafiq Joty. 2026. MAS-Orchestra: Understanding and improving multi-agent reasoning through holistic orchestration and controlled benchmarks. In Proceedings of the 43rd International Conference on Machine Learning, volume 306 of Proceedings of Machine Learning Research, pages 56527–56570. PMLR.arxiv.org/abs/2601.14652
- [15]Zixuan Ke, Austin Xu, Yifei Ming, Xuan-Phi Nguyen, Ryan Chin, Caiming Xiong, and Shafiq Joty. 2025. MAS-ZERO: Designing multi-agent systems with zero supervision. arXiv preprint arXiv:2505.14996.arxiv.org/abs/2505.14996
- [16]Yubin Kim, Ken Gu, Chanwoo Park, Chunjong Park, Samuel Schmidgall, A. Ali Heydari, Yao Yan, Zhihan Zhang, Yuchen Zhuang, Yun Liu, Mark Malhotra, Paul Pu Liang, Hae Won Park, Yuzhe Yang, Xuhai Xu, Yilun Du, Shwetak Patel, Tim Althoff, Daniel McDuff, and Xin Liu. 2026. Capable language models can act outgrow the benefits of collaboration. Nature Machine Intelligence, 8(7):1157–1172.DOI
- [17]Guohao Li, Hasan Abed Al Kader Hammoud, Hani Itani, Dmitrii Khizbullin, and Bernard Ghanem. 2023. CAMEL: Communicative agents for “mind” exploration of large language model society. In Advances in Neural Information Processing Systems, volume 36, pages 51991–52008. Curran Associates, Inc.arxiv.org/abs/2303.17760
- [18]Qi Li and Xinchao Wang. 2026. Sponge tool attack: Stealthy denial-of-efficiency against tool-augmented agentic reasoning. arXiv preprint arXiv:2601.17566.arxiv.org/abs/2601.17566
- [20]Yibo Li, Jiashuo Yang, Zhi Zheng, Zhiyuan Hu, Yuan Sui, Shizhuo Wang, Yufei He, and Bryan Hoo. 2026c. APEX: Autonomous policy exploration for self-evolving LLM agents. Preprint, arXiv:2605.21240.arxiv.org/abs/2605.21240
- [21]Hangui Lin, Yan Shu, Zhengyang Liang, Chi Liu, Xiangrui Liu, Minghao Qin, Teng Long, Zheng Liu, and Nicu Sebe. 2026. Dyco-rl: Dynamic cross-modal coordination for visual reasoning. arXiv preprint arXiv:2606.08035.arxiv.org/abs/2606.08035
- [22]Zijun Liu, Yanzhe Zhang, Peng Li, Yang Liu, and Divi Yang. 2024. A dynamic llm-powered agent network for task-oriented agent collaboration. In First Conference on Language Modeling.arxiv.org/abs/2310.02170
- [23]Aman Madaan, Niket Tandon, Prakhar Gupta, Skyler Hallinan, Luyu Gao, Sarah Wiegreffe, Uri Alon, Nouha Dziri, Shrimai Prabhumoye, Yiming Yang, Shashank Gupta, Bodhisattwa Prasad Majumder, Katherine Hermann, Sean Welleck, Amir Yazdanbakhsh, and Peter Clark. 2023. Self-Refine: Iterative refinement with self-feedback. In Advances in Neural Information Processing Systems, volume 36, pages 46534–46594. Curran Associates, Inc.arxiv.org/abs/2303.17651
- [24]MiroMind Team. 2025. MiroThinker: Pushing the performance boundaries of open-source research agents via model, context, and interactive scaling. Preprint, arXiv:2511.11793.arxiv.org/abs/2511.11793
- [25]MiroMind Team. 2026. MiroThinker-1.7 & H1: Towards heavy-duty research agents via verification. Preprint, arXiv:2603.15726.
- [26]Luke J. O’Connor. 2026. Self-programmed execution for language-model agents. Preprint, arXiv:2605.06898.arxiv.org/abs/2605.06898
- [27]Chen Qian, Wei Liu, Hongzhang Liu, Nuo Chen, Yufan Dang, Jiahao Li, Cheng Yang, Weize Chen, Yusheng Su, Xin Cong, Juyuan Xu, Dahai Li, Zhiyuan Liu, and Maosong Sun. 2024. ChatDev: Communicative agents for software development. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 15174–15186. Association for Computational Linguistics.arxiv.org/abs/2307.07924
- [28]Qwen Team. 2026. Qwen3.5: Towards native multi-modal agents. Official blog post. Accessed 2026-10-12.
- [29]David Rein, Betty Li Hou, Asa Cooper Stickland, Jackson Petty, Richard Yuanzhe Pang, Julien Dirani, Julian Michael, and Samuel R. Bowman. 2024. GPQA: A graduate-level google-proof Q&A benchmark. In First Conference on Language Modeling.arxiv.org/abs/2311.12022
- [30]Yan Shu, Hangui Lin, Yexin Liu, Yan Zhang, Gangyan Zeng, Yan Li, Yu Zhou, Sen Nam Lim, Harry Yang, and Nicu Sebe. 2026. When semantics mislead vision: Mitigating large multimodal models hallucinations in scene text spotting and understanding. Advances in Neural Information Processing Systems, 38:68952–68980.arxiv.org/abs/2506.05551
- [31]Lei Tan, Weihao Li, Pinyang Dai, Jie Chen, Liujuan Cao, and Rongrong Ji. 2026. Knowing where to focus: Attention-guided alignment for text-based person search. International Journal of Computer Vision, 134(2):72.arxiv.org/abs/2412.15106
- [32]Lei Tan, Jiaer Xia, Wenfeng Liu, Pinyang Dai, Yongjian Wu, and Liujuan Cao. 2024a. Occluded person re-identification via saliency-guided patch transfer. In Proceedings of the AAAI conference on artificial intelligence, volume 38, pages 5070–5078.
- [33]Lei Tan, Yukang Zhang, Keke Han, Pinyang Dai, Yan Zhang, Yongjian Wu, and Rongrong Ji. 2024b. Rle: A unified perspective of data augmentation for cross-spectral re-identification. Advances in Neural Information Processing Systems, 37:126977–126996.arxiv.org/abs/2411.01225
- [34]Katherine Tieu, Dongqi Fu, Yinglong Xia, Hong Li, Hong Yan, and Jingrui He. 2026. Inference-time graph engineering for multi-agent LLM workflows. arXiv preprint arXiv:2609.05774.arxiv.org/abs/2609.05774
- [35]Junlin Wang, Jue Wang, Ben Athiwatkun, Ce Zhang, and James Zou. 2025a. Mixture-of-agents enhances large language model capabilities. In International Conference on Learning Representations.arxiv.org/abs/2406.04692
- [36]Xingyu Wang, Yangyi Chen, Lifan Yuan, Yizhe Zhang, Yunzhu Li, Hao Peng, and Heng Ji. 2024. Executable code actions elicit better LLM agents. In Proceedings of the 41st International Conference on Machine Learning, volume 235 of Proceedings of Machine Learning Research, pages 50208–50232. PMLR.arxiv.org/abs/2402.01030
- [37]Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoc V. Le, Ed H. Chi, Sharan Narang, Aakanksha Chowdhery, and Denny Zhou. 2023. Self-consistency improves chain of thought reasoning in language models. In The Eleventh International Conference on Learning Representations.arxiv.org/abs/2203.11171
- [38]Yanbo Wang, Zixiang Xu, Yue Huang, Xiangqi Wang, Zirui Song, Lang Gao, Chenxi Wang, Robert Tang, Yue Zhao, Arman Cohan, Xiangliang Zhang, and Xiuying Chen. 2025b. DyFlow: Dynamic workflow framework for agentic reasoning. In Advances in Neural Information Processing Systems, volume 38, pages 174148–174181. Curran Associates, Inc.
- [39]Yiming Wang, Pei Zhang, Jialong Tang, Haoran Wei, Baosong Yang, Rui Wang, Chenshu Sun, Feitong Sun, Jiran Zhang, Junxuan Wu, Qiqian Cang, Yichang Zhang, Fei Huang, Junyang Lin, Fei Huang, and Jingren Zhou. 2025c. PolyMath: Evaluating mathematical reasoning in multilingual contexts. In Advances in Neural Information Processing Systems, volume 38. Curran Associates, Inc.arxiv.org/abs/2504.18428








