DynaFlow teaches a lead agent to write its own workflows, beats the baseline by 10.9 points

Researchers from 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 on its own when it needs help and writes a short executable program to get that help. Across six benchmarks, DynaFlow achieved 88.08% overall accuracy in Forced mode — 10.90 percentage points above the strongest baseline tested, with all systems compared on the same Qwen3.5-27B foundation.

Orchestration as an action, not a schema

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

In DynaFlow, workflow synthesis is built into the lead agent's action space, alongside its other reasoning steps. The agent itself decides whether collaboration is even needed. If it is, the agent generates a program tailored to the specific task. That program can run sub-agents sequentially or in parallel, exchange structured information between them, and verify intermediate results.

The key lies in the feedback loop. Execution results and traces are fed back to the lead agent and shape its next actions. The collaboration structure is reshaped as reasoning unfolds, rather than fixed at the outset.

Train the conductor, leave the musicians alone

The authors deliberately separated training the orchestrator from improving the executors. Only the lead agent is fine-tuned. All sub-agents stay unchanged, so the gains can't be attributed to the worker models simply getting stronger.

The process runs in two stages:

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

The filters are:

• unsupported premises: a conclusion relies on something that isn't in the source data;
• biased verification: the check confirms the result instead of actually evaluating it;
• information-flow defects: the output of one step is lost and never reaches the next one.

The third point is arguably the most interesting. The authors argue that the quality of a multi-agent system isn't determined by the number of agents or the elegance of the graph, but by whether the result of one step actually makes it to the next.

What the measurements showed

Evaluation ran on six benchmarks covering mathematical reasoning, scientific question answering, and multi-hop search — tasks where the answer is assembled from multiple steps or sources.

Key figures:

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

Analysis of the generated workflows after training showed that the agent more often explicitly uses the outputs of previous steps, verifies them, and refines them. Before training, those connections between steps showed up less often. The authors call this cross-step information handoff one of the key measures of orchestration quality.

What teams can take away from this

This work reads like a recipe rather than a closed product. The code is up on GitHub (amiya-special/Dynaflow), there's a project page, and a paper on arXiv numbered 2610.34467. At the time of publication, the repository is brand new (around three stars), and the paper's page on Hugging Face isn't linked to any models, datasets, or Spaces. Reproducing the result will take some work on your own.

For teams building agentic systems, the practical takeaways are these. First, it's worth treating orchestration as a trainable skill. A mid-sized, 27-billion-parameter model can learn to build its own workflows without requiring an expensive full retraining cycle for every participant. Second, when assembling training trajectories, it pays to filter data by behavior: check whether the verifier is rubber-stamping everything and whether intermediate results are getting lost. Third, when evaluating multi-agent systems, it's worth looking not just at final accuracy but at the traces themselves — specifically, how the outputs of previous steps get used.

The limitations are visible too. These results come from math, science questions, and multi-hop search. How DynaFlow performs in long coding sessions or when working with external tools remains unknown. But the core idea — that an agent writes the program for its own coordination and learns to do so carefully — already looks workable and reproducible.