DynaFlow Teaches a Lead Agent to Write Workflows and Beats the Strongest Baseline by 10.9 pp

Researchers at the National University of Singapore (Ruhao Liu, Qi Li, Shizun Wang, Xinchao Wang) have published DynaFlow, a framework for multi-agent orchestration. In it, the lead agent decides for itself when it needs help and writes a short executable program to get it. On six benchmarks, DynaFlow reached 88.08% overall accuracy in Forced mode. That is 10.90 percentage points above the strongest baseline system tested, and all systems were compared on the same Qwen3.5-27B foundation.

Orchestration as an action, not a scheme

Most multi-agent systems are rigid. They have a predefined structure: a planner, an executor, a critic, and a fixed order for passing messages. For tasks that don't fit the template, that structure becomes a ceiling.

In DynaFlow, workflow synthesis is part of the lead agent's action space, on par with the other reasoning steps. The agent decides whether collaboration is needed at all. If it is, the agent generates a program tailored to the specific task. The program can launch subagents sequentially or in parallel, exchange structured information between them, and check intermediate results.

The feedback loop is the key part. Execution results and traces go back to the lead agent and shape its next actions. The collaboration structure is rebuilt as the reasoning unfolds rather than fixed at the start.

Training the conductor, leaving the musicians alone

The authors deliberately separated training the orchestration from improving the executors. Only the lead agent is fine-tuned. All subagents stay unchanged, so the gain cannot be attributed to the worker models getting stronger.

The process has two stages:

• Supervised fine-tuning on distilled trajectories: the lead agent learns from ready-made examples how to build workflows.
• Further training on filtered examples: trajectories with three types of defects are removed from the dataset.

The filters are:

• unsupported premises: the conclusion rests on something that is not in the source data;
• biased verification: the check confirms the result instead of evaluating it;
• information-flow defects: the output of one stage is lost and never reaches the next.

The third item is arguably the most interesting. The authors argue that the quality of a multi-agent system is determined not by the number of agents or the elegance of the graph, but by whether the result of one step reaches the next.

What the measurements showed

The evaluation ran on six benchmarks covering mathematical reasoning, scientific question answering and multi-hop search, that is, tasks where the answer is assembled from several steps or sources.

Key parameters:

• Foundation: Qwen3.5-27B, the same for DynaFlow and the baseline systems.
• Overall accuracy: 88.08% in Forced mode.
• Margin: +10.90 pp over the strongest baseline system tested.
• Trained component: the lead agent only; the subagents are frozen.
• Method: SFT on distilled trajectories, followed by filtering for three types of defects.

An analysis of the generated workflows after training showed that the agent more often explicitly uses the outputs of earlier stages, checks them and refines them. Before training, such links between steps appeared less often. The authors call this cross-stage information transfer one of the main dimensions of orchestration quality.

What you can take away for your own work

The work looks like a recipe rather than a closed product. The code is on GitHub (amiya-special/Dynaflow), and there is a project page and a paper on arXiv under number 2610.34467. At the time of publication, the repository is brand new (about three stars), and the paper's Hugging Face page has no models, datasets or Spaces attached. You will have to reproduce the result yourself.

For teams building agent systems, the practical takeaways are as follows. First, it is worth trying orchestration as a trainable skill. A mid-sized 27B-parameter model learns to build its own workflows, and this does not require an expensive full retraining cycle for every participant. Second, when assembling training trajectories, it helps to filter data by behavior: check whether the verifier confirms everything indiscriminately and whether intermediate results get lost. Third, when evaluating multi-agent systems, look not only at final accuracy but also at the traces, in particular at how the outputs of earlier steps are used.

The limitations are visible too. The results were obtained on math, scientific questions and multi-hop search. How DynaFlow will behave in long coding sessions or when working with external tools is not yet known. But the core idea, that an agent writes the program for its own coordination and learns to do it carefully, already looks workable and reproducible.