acceptodds
Under review as a conference paper at ICLR 2027

It Takes Workflows to Evolve Better Workflows

Abstract

Tackling complex real-world tasks can go beyond the ability of a single large language model (LLM), so LLMs increasingly construct multi-agent workflows that coordinate specialized agents to solve them. Recent methods train LLMs to construct better workflows from execution outcomes, but they optimize only the workflow generator, while the other agents that build or execute each workflow remain fixed even though every outcome depends on all of them. However, extending training beyond the generator is challenging: the agents are coupled, and a workflow's outcome is a single sparse score that cannot tell which agent causes a failure. We propose FloWright, which leverages the workflow as a harness to optimize workflows. By introducing a hierarchical, structure-aware reward paradigm, FloWright enables one role to self-evolves and two or more roles to co-evolve, with no additional models, labels, or executions. Considering the limitation that workflows are commonly trained and evaluated on data that a single agent can already handle, we further propose DataWright, an adaptive data hardening approach that converts existing datasets into workflow-level tasks with increased difficulty.

Primary area:
unsupervised, self-supervised, semi-supervised, and supervised representation learning
Keywords:
workflow optimization, reinforcement learning, agent evolution, multi-agent workflow, multi-agent system

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_CipMOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper proposes FlowRight, a framework for optimizing multiple roles involved in constructing and executing LLM workflows. It also introduces DataWright, which constructs harder evaluation tasks through question bundling and distractor inputs. The experiments demonstrate the framework is potentially useful. However, the paper does not clearly show that tasks created by DataWright require workflow coordination, or that coevolution itself drives the performance gains.

Critical strengths
  1. The framework accommodates workflow generation, component invention, and downstream execution within a common training setup.
  2. Beyond the training distribution, improvements also appear in the aggregate results for unseen task configurations and domains, providing encouraging evidence of generalization.
Critical weaknesses
  1. DataWright does not establish that its tasks require learned workflow coordination. Shared and Paired tasks combine independent questions, while Decoy tasks mainly require finding the relevant input. A fixed workflow that solves each question separately may perform similarly. The paper should compare against this baseline and a single agent with comparable resources to show that the gains come from learned coordination.
  2. The paper does not specify which roles are trained together or how they are updated. It is therefore unclear whether the reported gains come from mutual adaptation or simply from training more components. A useful control would train the roles independently and then combine them under the same total training budget.
  3. Section 3.5 does not explain where the successful examples used for test time distillation come from, when the resulting prior is fixed, or whether it changes across test tasks. These details are needed to interpret the reported gains. The authors should also clarify why Table 3 lists training questions for DocFinQA, which Section D.5 describes as used only for evaluation.
  4. Section D.4 uses token-level F1 for open-ended answers in Shared and Paired tasks, but exact match in Decoy tasks. Scores across these strategies are therefore not directly comparable. Table 3 also lists 1,065 test questions for InfoChartQA Visual at level 3 and 1,735 at level 5 under Paired, making it unclear whether the two levels use the same question pool. The authors should report results with consistent scoring and matched questions.
Questions for authors

See weaknesses.

7 comments
AuthorsOpenReview ↗

Author Response (1/2): Thank you for your valuable review and insightful feedback

Thank you for your careful review and constructive feedback, and for recognizing our training setup for workflow generation, component invention, and downstream execution, and our encouraging evidence of generalization. We hope to further address your remaining concerns below.

W1: Workflow coordination in DataWright tasks

Thank you for your insightful comment. We hope to respectfully clarify that DataWright constructs tasks beyond a single agent's ability (App. C), while learned coordination comes from FloWright's training. Below, we show results against a fixed workflow and a single agent with comparable resources.

1. Single agent with comparable resources. Tab. 1 already includes a single agent with the same tools, skills, sandbox, and run limits, which receives on each test sample the agent turns the compared workflow used on that sample. The untrained FloWright outperforms it by +11.39 at 4B and +16.75 at 9B overall (Tab. 1). On MMLongBench-Doc hardened by DataWright, the same workflow reaches 51.61% against the single agent's 12.33% (App. C). We will add these budget matching details to §F.2.

2. Fixed per-question workflow (W1 "A fixed workflow that solves each question separately may perform similarly"). The untrained FloWright, the reference of every gain in Tab. 1, already splits a bundled task into steps (9.74 per workflow on average at 4B) and aggregates their answers (Fig. 11). Over it, training improves accuracy by up to +5.03% at 4B (Tab. 1). To further validate, we additionally compare with AFlow [1], which searches one fixed workflow per dataset on labeled training tasks and applies it to every test task, with Qwen3.5-9B and our tools, skills, sandbox, budget, and run limits. On the 23 arms with training splits, the untrained FloWright is higher than AFlow in every arm (42.51% vs. 34.61% mean accuracy).

3. Gains with nothing to decompose. Each Decoy task holds a single question among decoy inputs (§D.1). On all 8 Decoy arms, the untrained FloWright outperforms the single agent with tools and skills by 6.96 at 4B and 12.03 at 9B on average, and every 4B mode improves all 8 arms further, by about as much as on Shared and Paired (§G.1). The gains therefore come from learned workflow construction beyond per-question decomposition.

W2: Roles trained together and their updates

Thank you for your thoughtful comment.

1. Roles and updates (W2 "which roles are trained together or how they are updated"). Mode (b) trains the Generator and the Inventor skill, (c) the Generator and the downstream agent, and (d) all three. Each role is its own policy with no shared weights, and co-evolving roles learn from one shared set of rollouts, each taking one optimizer step per training step. In our revision, we will state this clearly in §3.4.

2. Roles trained independently, then combined (W2 "train the roles independently and then combine them under the same total training budget"). Following your suggestion, we combine the roles from their own single-role training (Fig. 14) into one system. GPU-hours count one role's GPUs as one unit, and one single-role run takes 50.04 GPU-hours and 8,000 rollouts. We show overall accuracy (%) with Qwen3.5-4B below:

ModeGPU-hours (separate / co-evolved)Rollouts (separate / co-evolved)Separately trainedCo-evolution gain (Tab. 1)
(b) agent-skill100.08 / 108.4016,000 / 8,00029.79+6.36
(c) upstream-downstream100.08 / 108.4016,000 / 8,00031.93+3.22
(d) multi-agent150.12 / 169.7424,000 / 8,00030.64+6.48

With 1.08-1.13 times the GPU-hours and one shared set of rollouts, co-evolution is 3.22-6.48 points higher, while the separately trained roles fall below even the untrained workflow (Tab. 1). The gain thus comes from the roles adapting to each other during co-evolution rather than from training more roles.

AuthorsOpenReview ↗

Author Response (2/2): Thank you for your valuable review and insightful feedback

W3: Test-time distillation and DocFinQA

Thank you for your detailed comments.

1. Test-time distillation: Internal distillation draws reusable knowledge from the system's own trajectories on earlier tasks of the same test stream, and external distillation uses a stronger teacher as the distiller (§3.5). A successful example is a workflow that executes to a final answer, so the distiller never receives a grade, a label, or a reference answer. The prior is updated every NN tasks (N=30N = 30 by default): the first NN tasks use the base prior, and each later block uses the prior distilled from the blocks before it, fixed within that block. The prior thus changes across test tasks by design, online and without gradients, and is never fitted to the task being answered. In our revision, we will state NN, this schedule, and the source of the trajectories in §3.5.

2. DocFinQA: We respectfully clarify that DocFinQA serves only for evaluation: RL trains and validates only on the Paired ℓ=3 arms of InfoChartQA-Visual, TACO, SlideVQA-Doc, and LongDocURL (Tab. 1). DataWright also builds a training split to benefit future research since DocFinQA's original dataset has a training split. But no training, distillation, or pool growth uses it, and we will mark this clearly in Tab. 3 in our revision.

W4: Consistent scoring and matched questions

Thank you for your careful comments.

1. Consistent scoring (W4 "report results with consistent scoring"). Every comparison is within an arm, where all methods share one metric, so the metric cannot favor a method. We nevertheless re-score the Decoy text answers with the partial credit of Eq. 9 that Shared and Paired already use, on the six Decoy arms with text answers (DocFinQA's numeric answers receive no partial credit). We show the gain (%) over the untrained FloWright with Qwen3.5-4B below:

ModeExact match (paper)Consistent scoring
(a) single-role+3.61+4.43
(b) agent-skill+4.93+6.05
(c) upstream-downstream+4.18+5.43
(d) multi-agent+5.32+6.89

Every mode stays above the untrained workflow in all six arms, and every gain grows. We will add these results to §G.1 and note the Decoy scoring in §4.

2. Matched questions (W4 "making it unclear whether the two levels use the same question pool"). Both levels draw from the same InfoChartQA-Visual test pool: 1,048 of the 1,065 ℓ=3 questions also appear at ℓ=5. The two levels hold a similar number of tasks (355 and 347) with three and five questions each, so ℓ=5 draws more questions (1,735) from that pool. On the 194 questions evaluated at both levels, the gain (%) over the single agent with tools and skills below shows that FloWright's lead grows at the higher level, with Qwen3.5-4B:

MethodGain over the single agent, ℓ=3Gain over the single agent, ℓ=5
FloWright, untrained+14.07+19.59
FloWright, (d) multi-agent+22.44+25.46

In our revision, we will add these matched results to §G.1 and clarify the question counts of this dataset in §D.5.

References

[1] J. Zhang et al. AFlow: Automating Agentic Workflow Generation. 2025.

Thank you for your valuable review and constructive feedback. We sincerely hope our response and clarifications above can meaningfully address your remaining concerns, and we will make sure to apply them to our revisions to further enhance our paper quality.

Thank you for your rebuttal. I have carefully read your responses and appreciate the clarifications. I will maintain my current score. Best of luck!

Reviewer_vLiDOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper introduces FlowRight, a framework for jointly optimizing the agents that construct and execute LLM workflows using hierarchical, trace-based rewards. It supports single-role and multi-role co-evolution, as well as test-time distillation from successful experiences. The authors also propose DataWright, which converts existing datasets into harder workflow-level tasks. Across 44 settings from 12 datasets, FlowRight outperforms single-agent baselines, with multi-role co-evolution achieving the largest gains.

Critical strengths
  1. The motivation is sound: if the executors never learn, there is a ceiling on what training the planner can achieve. Appendix C shows that a workflow loses to a single agent on MMLongBench-Doc and DocFinQA under matched compute, and the survey of 20 workflow papers shows that most evaluate on tasks a single agent can already solve.
  2. The reward design is simple and role-agnostic, so the same recipe trains very different roles. I appreciate that the validity terms are deterministic rather than judged by another LLM.
  3. The evaluation has broad nominal coverage. The experiments span document, slide, chart, mathematics, finance, science, and coding tasks, along with four workflow representations and three optimization algorithms. The ablations across reward terms, pool configurations, RL optimizers, and optimized roles is also useful.
Critical weaknesses
  1. The central credit-assignment claim is not substantiated. The paper claims that the execution trace identifies the nodes that “root-cause a failure,” producing role-level credit without an additional model, label, or execution. However, neither Section 3.2 nor Appendix E.1 explains how a trace can determine that a successfully executed but semantically incorrect output caused the final answer to be wrong. Also, the "no additional executions" claim conflicts with the Planner/Critic helpfulness reward, which is defined as the gain over the same flow without one. That requires a counterfactual run.
  2. Everything is compared to either a single agent or the untrained version of FloWright. There is no comparison to any prior trained workflow generator, multi-agent RL method or or prompt optimizer for the test-time part. Besides, every reported number comes from a single training run while several conclusions rest on gaps under 1 point (credit adds +0.69; upstream-downstream co-evolution beats generator-only by +0.23; the trained 4B generator beats all-9B by +0.17).
  3. The benchmark construction raises several concerns. DocFinQA is classified as out-of-domain, yet Table 3 reports training counts for it and Appendix D.3 discusses filtering its training data, so it is unclear whether it contributed to RL training, distillation, or pool growth. The out-of-domain label also seems overstated because many evaluation arms remain close to the training domains, and the InfoChartQA subsets may share underlying images. More importantly, the evaluation metric changes across hardening strategies: Shared and Paired allow token-F1 partial credit, whereas Decoy uses exact match, contradicting the claim that hardening changes only task difficulty and potentially confounding the reported gains. The paper should provide complete split and filtering statistics, audit overlap at the underlying image/document level, use consistent metrics across strategies, and validate that Decoy tasks remain uniquely answerable.
Questions for authors
  1. Validity accounts for most of the gain in Fig. 5. Does training mainly help the Generator produce valid workflows, or also better ones? For example, does accuracy conditional on successful execution improve, and does the structure of generated workflows change after training?
  2. Which roles are trained in each co-evolution mode, and do they share weights? Is the advantage of co-evolution over single-role training still present at matched training compute?
  3. How is the single agent’s compute budget matched and used, and how does it handle hardened inputs that exceed its context window?
3 comments
AuthorsOpenReview ↗

Author Response (1/2): Thank you for your valuable review and insightful feedback

Thank you for your careful review and constructive feedback, and for recognizing our sound motivation, our simple and role-agnostic reward design with deterministic validity terms, and our broad evaluation coverage. We hope to further address your remaining concerns below.

W1: Credit from the execution trace

1. Semantically incorrect outputs: The credit term is designed to credit the structure (§3.2), not the semantics: it charges a role only for its own nodes whose final execution fails in the trace, excluding infrastructure faults and failures cascaded from an upstream node (§E.1). A node that completes with a semantically incorrect output is left to the answer reward that every role receives (Eq. 3, §E.1). In our revision, we will state clearly in §3.2 "the role's own nodes that root-cause a node failure recorded in the trace".

2. Helpfulness reward: We agree that the helpfulness of the Planner and the Critic requires baseline execution without the role. Our main settings train the Generator, the Inventor skill, and the downstream agent (Tab. 1, Figs. 13-14), whose rewards read only the graded run and its trace with no additional executions. In our revision, we will restrict "no additional models, labels, or executions" in the abstract to the credit term and these main settings, and state the additional execution of the helpfulness reward in Tab. 4.

W2+Q2: Existing methods, training compute, and training runs

1. Trained workflow generator (W2 "comparison to any prior trained workflow generator"). Generator-only training (a) follows prior trained generators, which optimize a single workflow generator against execution outcomes (§1), and every co-evolution mode outperforms it (Tab. 1). We further add MaAS [1] (a trained workflow generator) and AFlow [2] (a workflow optimizer) from their official code, matched with Qwen3.5-9B and our tools, skills, sandbox, budget, and run limits, on 23 arms with training splits. Accuracy (%) below shows that untrained FloWright is higher than both baselines, and is also higher in each of the 23 arms:

MethodMean over 23 arms
AFlow34.61
MaAS34.80
FloWright, untrained42.51
FloWright, (d) multi-agent52.49

2. Multi-agent RL and roles (W2 "multi-agent RL method", Q2 "Which roles are trained in each co-evolution mode, and do they share weights?"). Prior multi-agent RL trains each agent separately (§A.2), so we train each of our roles in its own single-role run (Fig. 14) and combine the trained roles into one system. Mode (b) trains the Generator and the Inventor skill, (c) the Generator and the downstream agent, and (d) all three. Each role is its own policy with no shared weights, and co-evolving roles learn from one shared set of rollouts, each taking one optimizer step per training step. GPU-hours count one role's GPUs as one unit, and one single-role run takes 50.04 GPU-hours and 8,000 rollouts (Q2 "at matched training compute"). We show mean accuracy (%) with Qwen3.5-4B below:

ModeGPU-hours (separate / co-evolved)Rollouts (separate / co-evolved)Separately trainedCo-evolution gain (Tab. 1)
(b) agent-skill100.08 / 108.4016,000 / 8,00029.79+6.36
(c) upstream-downstream100.08 / 108.4016,000 / 8,00031.93+3.22
(d) multi-agent150.12 / 169.7424,000 / 8,00030.64+6.48

With 1.08-1.13$\times$ the GPU-hours and one shared set of rollouts, co-evolution is 3.22-6.48 higher, while the separately trained roles fall below even the untrained workflow (Tab. 1).

3. Test-time part (W2 "prompt optimizer for the test-time part"). We add GEPA [3], which optimizes the same Generator prior as our distillation (Eq. 5), with Qwen3.5-4B for every role and for reflection. Accuracy (%) on all 44 arms below validates that our distillation is higher than GEPA in every regime:

MethodLabelsExecutions before testingIn-Dist.Out-of-DistributionOut-of-DomainOverall
FloWright, untrained (Fig. 3)––31.9129.2433.4832.09
+ GEPAyes1,04332.1929.3433.6232.23
+ Internal distillation (Fig. 3)no034.0230.6434.0233.02
+ Meta distillation, 5-shot (Fig. 3)no034.4831.8234.5133.71

4. Single training runs (W2 "every reported number comes from a single training run while several conclusions rest on gaps under 1 point"). Evaluation uses greedy decoding (Tab. 6), so every number is reproducible for its trained model. Paired Wilcoxon tests over the 44 test arms show that every mode is higher than the untrained FloWright (+2.83 to +5.03, p ≤ 3.6e-7), and (b)-(d) are also higher than (a) (+1.23 to +2.20, p = 7.9e-4 to 2.7e-4). Beyond +0.69 (GRPO) and +0.75 (DAPO) in Fig. 5, the credit term also improves each co-evolution mode, by +0.57 to +1.43. We will state these details in our revision.

AuthorsOpenReview ↗

Author Response (2/2): Thank you for your valuable review and insightful feedback

W3: Benchmark construction

1. DocFinQA (W3 "whether it contributed to RL training, distillation, or pool growth"). It contributes to none of them. RL trains and validates only on the Paired ℓ=3 arms of InfoChartQA-Visual, TACO, SlideVQA-Doc, and LongDocURL (Tab. 1). DataWright also builds a training split to benefit future research since DocFinQA's original dataset has a training split. But no training, distillation, or pool growth uses it, and we will mark this clearly in Tab. 3, together with complete split and filtering statistics per dataset, in our revision.

2. Out-of-domain arms and shared images (W3 "audit overlap at the underlying image/document level"). Out-of-domain denotes the 8 datasets never used in training (Tab. 1). On its 10 arms whose domain is also unseen (DocFinQA, MMMU-Pro, We-Math), every 4B mode gains more than on the other 17 out-of-domain arms: +3.03 to +7.05 against +1.34 to +2.90. The content audit finds no overlap: among the 18,622 input files of all test arms and the four training datasets, no test file shares its content with a training file, and none of the 610 InfoChartQA-Text and -Metaphor test charts appears in training.

3. Consistent metrics (W3 "use consistent metrics across strategies"). Every comparison is within an arm, where all methods share one metric, so the metric cannot favor a method. We nevertheless re-score the Decoy text answers with the partial credit of Eq. 9 that Shared and Paired already use, on the six Decoy arms with text answers (DocFinQA's numeric answers receive no partial credit). We show the gain (%) over the untrained FloWright with Qwen3.5-4B below:

ModeExact matchConsistent scoring
(a) single-role+3.61+4.43
(b) agent-skill+4.93+6.05
(c) upstream-downstream+4.18+5.43
(d) multi-agent+5.32+6.89

Every mode stays above the untrained workflow in all six arms, and every gain grows. We will add these results to §G.1 and note the Decoy scoring in §4.

4. Uniquely answerable Decoy tasks (W3 "validate that Decoy tasks remain uniquely answerable"). Following your suggestion, we use GPT-6.1-terra to validate whether any decoy, given all its pages as text and image, can answer the question. This shows that 92% of the evaluated Decoy tasks are uniquely answerable, and on them (d) gains +5.06 at 4B and +9.23 at 9B over the untrained FloWright. We will add this validation in our revision.

Q1: Conditional accuracy & workflow change

Thank you for your insightful question. Every bar in Fig. 5 is task accuracy, and validity is the reward term with the largest increment. We compare the untrained and trained Generator over the 44 arms with Qwen3.5-4B:

MethodConditional accuracyStepsWith parallel branches (%)With a loop (%)Distinct agents
FloWright, untrained33.729.7460.323.384.69
(a) single-role36.238.6953.085.875.27

Conditional accuracy rises by +2.51, close to the +2.83 gain in accuracy (Tab. 1), so training yields better workflows, not only valid ones.

Q3: Single-agent budget and context

Thank you for your thoughtful question. On each test sample, the single agent receives the agent turns the compared workflow used on that sample, counting every executed step and loop iteration (median 9 at 4B and 11 at 9B), with the same executor, sandbox, tools, skills, and run limits (Q3 "How is the single agent's compute budget matched and used"). It reads input files through tool calls that each return only part of a file, such as selected pages of a PDF. So a long input enters its context only in the parts it reads. When the conversation length reaches the context limit, its earlier turns are automatically compacted, so intermediate progress is kept (Q3 "how does it handle hardened inputs that exceed its context window?"). We will add these details to §F.2.

References

[1] G. Zhang et al. Multi-agent Architecture Search via Agentic Supernet. 2025.

[2] J. Zhang et al. AFlow: Automating Agentic Workflow Generation. 2025.

[3] L. A. Agrawal et al. GEPA: Reflective Prompt Evolution Can Outperform Reinforcement Learning. 2026.

Thank you for your valuable review and constructive feedback. We sincerely hope our response and clarifications above can meaningfully address your remaining concerns, and we will make sure to apply them to our revisions to further enhance our paper quality.

AuthorsOpenReview ↗

Author Response on Revision Update: Thank you for your valuable review and insightful feedback

Thank you very much for your thoughtful review. We have revised our paper following your suggestions:

  • W1 (credit from the execution trace): We state in §3.2 that the credit goes to the role's own nodes that root-cause an execution failure in the trace. We also restrict "no additional models, labels, or executions" in the abstract to localizing this credit. We further state in §E.3 and Tab. 4 that the helpfulness reward takes one additional execution.
  • W2+Q2 (existing methods, training compute, and training runs): We add comparisons with existing workflow optimization methods AFlow and MaAS to §G.3. Both are matched with our pools, sandbox, budget, and run limits. Also, we add an adapted GEPA to compare test-time optimization. We update §3.4 and §4 (Setup) to show which roles co-evolve in each mode and clarify that each role keeps its own policy. We further show the training details in §F.2. In §G.5, we add the comparison with the same roles trained separately at comparable training compute. We further show the credit term ablation in every co-evolution mode, and add paired Wilcoxon tests over the 44 arms with greedy decoding.
  • W3 (benchmark construction): We mark in Tab. 3 that DocFinQA's training split is unused (§D.5). We also state that Tab. 3 shows the data statistics after quality control. We add a content audit to §D.3, which confirms that no test input file shares its content with a training file. In §G.1, we add the gains on domains that are never seen during training. We also validate the results under the partial credit that Shared and Paired already use, and validate that 92% of the evaluated Decoy tasks are uniquely answerable. We further note how Decoy answers are scored in §4.
  • Q1 (conditional accuracy and workflow change): We add the accuracy among workflows that execute to a final answer to §G.6. We also show how the workflow structure changes after training.
  • Q3 (single-agent budget and context): We state in detail how each single-agent baseline matches the budget of the corresponding workflow in §F.2. We also state how it handles inputs that exceed its context window and keeps the intermediate results.

Sincerely thank you again for your valuable review and detailed comments. We hope our responses and revision can meaningfully address your remaining concerns, and we would be very grateful if you could take them into consideration in your assessment of our paper.

Reviewer_CCGvOpenReview ↗
Rating
3(+1)
Confidence
4
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper introduces FLOWRIGHT, a framework for training the LLM roles that construct and execute task-specific workflows. Beyond the workflow generator, it supports optimizing roles such as the component inventor and execution agents, individually or through co-evolution. Its reward combines final-answer correctness with role-specific format and validity checks and trace-derived failure penalties. It also explores gradient-free test-time optimization through reusable priors distilled from successful experiences.

For evaluation, the paper proposes DATAWRIGHT, which transforms existing datasets by bundling questions or adding distractor inputs, producing 44 evaluation settings across 12 datasets and seven domains.

Experiments train on four settings and evaluate generalization to unseen datasets, hardening strategies, and difficulty levels. With Qwen3.5-4B, multi-agent co-evolution improves the overall score by 5.03 percentage points over the untrained workflow, compared with 2.83 points for generator-only training. Additional experiments examine generator training at 9B, mixed backbones, reward components, RL algorithms, workflow representations, component pools, and test-time optimization.

Critical strengths
  1. The framework provides a unified approach to optimizing roles involved in both workflow construction and execution. Final-answer correctness is supplemented by role-specific validity checks and trace-derived failure penalties, allowing training to extend beyond the generator. The reported advantage of multi-agent co-evolution over generator-only training supports the promise of improving multiple components within the same workflow system.

  2. The experiments examine generalization beyond the training configuration across a broad range of settings. Training uses four settings, while evaluation covers 44 settings spanning unseen datasets, hardening strategies, and difficulty levels. Ablations additionally examine reward components, RL algorithms, workflow representations, and component pools. This provides evidence that the improvements extend beyond the specific training settings and helps assess which design choices contribute to performance.

Critical weaknesses
  1. The co-evolution results are promising, but the source of the improvement remains insufficiently isolated. The paper reports an advantage over generator-only training, yet does not clarify whether total training compute is comparable or evaluate a combination of independently trained roles. These comparisons would help determine how much the gain reflects mutual adaptation during training. Similarly, the reward ablation does not separately establish the contribution of role-localized credit in the multi-agent setting. This limits the evidence for the proposed mechanisms underlying the co-evolution gains.

  2. The comparative evaluation leaves important questions about the framework’s benefits unresolved. The experiments include single-agent baselines and internal variants, but no direct comparison with an existing workflow optimization method. Although inference budgets are described as matched, the budget measure and the single agent’s ability to process inputs across multiple calls are not sufficiently specified. Since Shared and Paired tasks bundle independently answerable sub-questions, a simple decomposition-and-aggregation baseline would also help distinguish the benefits of the proposed framework from those of task decomposition alone. These gaps limit the conclusions that can be drawn about its comparative effectiveness.

Questions for authors
  1. To interpret the performance difference between co-evolution and generator-only training, could you clarify how their total training compute compares?

  2. The paper attributes the benefits of co-evolution to mutual adaptation among roles. Do the existing experiments or observations during training provide evidence that distinguishes this effect from the benefit of training multiple roles?

  3. The reward ablation shows an incremental benefit from the credit term, but its contribution under multi-agent co-evolution is unclear. Could you clarify whether this setting is covered and, if not, provide a representative comparison with and without the credit term while retaining the other rewards?

  4. The paper states that single-agent and workflow baselines receive the same compute budget. To interpret this comparison, could you explain how the budget is matched and how the single-agent baseline reads multiple inputs and retains intermediate results?

  5. To assess the framework’s effectiveness relative to existing approaches, could you provide a comparison with an existing workflow generation or optimization method on representative evaluation settings, using the same backbone and tools with comparable computational budgets?

  6. Stronger base models may change the additional benefit of co-evolution. While the paper includes 9B generator-only training and mixed-backbone experiments, could you provide evidence on whether the advantage of co-evolution over generator-only training also holds at a larger model size, even on a representative subset of tasks?

5 comments
AuthorsOpenReview ↗

Author Response (1/2): Thank you for your valuable review and insightful feedback

Thank you for your careful review and constructive feedback, and for recognizing our unified approach to optimizing the roles that construct and execute workflows, and our broad generalization study. We hope to further address your remaining concerns below.

W1+Q1+Q2: Training compute and mutual adaptation

Thank you for your insightful questions. We hope to respectfully clarify the training and add the comparison below.

1. Training (Q1 "how their total training compute compares"). Every role in every mode uses the configuration of Tab. 6. Co-evolving roles learn from one shared set of rollouts, each takes one optimizer step per training step, and each is its own policy with no shared weights. In our revision, we will state this clearly in §3.4.

2. Same roles trained separately, then combined (W1 "evaluate a combination of independently trained roles", Q2 "distinguishes this effect from the benefit of training multiple roles"). Following your suggestion, we combine the roles from their own single-role training (Fig. 14) into one system and evaluate it. GPU-hours count one role's GPUs as one unit, and single-role self-evolution takes 50.04 GPU-hours and 8,000 rollouts. We compare the combined roles with co-evolution below, in compute and overall accuracy (%) with Qwen3.5-4B:

ModeGPU-hours (separate / co-evolved)Rollouts (separate / co-evolved)Separately trainedCo-evolution gain (Tab. 1)
(b) agent-skill100.08 / 108.4016,000 / 8,00029.79+6.36
(c) upstream-downstream100.08 / 108.4016,000 / 8,00031.93+3.22
(d) multi-agent150.12 / 169.7424,000 / 8,00030.64+6.48

With 1.08-1.13$\times$ the GPU-hours and one shared set of rollouts, co-evolution is 3.22-6.48 higher. Yet the separately trained combinations fall below even the untrained workflow (Tab. 1). The gain thus comes from the roles adapting to each other during co-evolution rather than from training more roles. Fig. 13 shows the same effect: a 9B Generator and Inventor skill with a 4B downstream agent fall below the all-4B system, and two 4B roles co-evolved inside a 9B system exceed each of them trained alone.

W1+Q3: Credit term under co-evolution

Thank you for your thoughtful question. Yes, Fig. 5 isolates the credit term only under single-role self-evolution (Q3 "whether this setting is covered"), where the credit is already role-localized, since the Generator authors every node. We additionally add the co-evolution setting (Q3 "a representative comparison with and without the credit term while retaining the other rewards"): each mode is trained with wc=0w_c = 0 instead of 0.10.1 (§F.1), with every other reward unchanged. Comparing their overall accuracy (%) with Qwen3.5-4B shows that the credit term also improves every co-evolution mode:

ModeWithout creditCredit gain (Tab. 1)
(a) single-role (Fig. 5)34.23+0.69
(b) agent-skill34.72+1.43
(c) upstream-downstream34.58+0.57
(d) multi-agent36.09+1.03

W2+Q4: Single-agent budget

Thank you for kindly noting this. We hope to respectfully clarify the matching, and we will add these budget matching details to §F.2.

1. Budget (W2 "the budget measure", Q4 "how the budget is matched"). On each test sample, the single agent receives the number of agent turns the compared workflow actually used on that sample, summed over its executed steps and counting loop iterations (median 9 at 4B and 11 at 9B). It runs on the same workflow executor, with the same sandbox, staged inputs, graders, run limits, and tool and skill pools in Ω\Omega (§3.1).

2. Inputs and intermediate results (Q4 "how the single-agent baseline reads multiple inputs and retains intermediate results"). It reads input files through tool calls, one tool or skill call per turn, and keeps all intermediate results in its own conversation across its turns. When the conversation length reaches the context limit, its earlier turns are automatically compacted, so intermediate progress is kept.

AuthorsOpenReview ↗

Author Response (2/2): Thank you for your valuable review and insightful feedback

W2+Q5: Comparison with existing workflow methods

Thank you for your kind suggestion. We add AFlow [1] (a workflow optimizer) and MaAS [2] (a trained workflow generator) from their official code (Q5 "using the same backbone and tools"), with Qwen3.5-9B for every role, evaluated across two settings: original (as released) and matched (with our tools, skills, sandbox, budget, and run limits). Both need labeled tasks of each test arm, so they run on 23 arms whose datasets have a training split. We summarize accuracy (%) below as the mean over each dataset's arms:

MethodInfoChartQA-VisualTACOSlideVQA-DocLongDocURLDocFinQAMean over 23 arms
AFlow (original)0.000.008.033.491.003.27
AFlow (matched)44.9633.7029.7837.9031.3034.61
MaAS (original)0.000.003.523.420.561.96
MaAS (matched)42.6136.0030.1838.2231.7134.80
FloWright, untrained50.5538.4737.7948.5838.4942.51
FloWright, (d) multi-agent59.2949.1149.2458.3147.6452.49

The untrained FloWright is higher than the better matched baseline in all 23 arms. In their original design, neither baseline can directly read an input file path such as an image or a document, and MaAS does not terminate on TACO. These arms therefore count as 0.

W2: Decomposition and aggregation

Thank you for your insightful comment. We hope to respectfully clarify that our comparisons already separate the benefits of FloWright from those of task decomposition (W2 "distinguish the benefits of the proposed framework from those of task decomposition alone").

1. Training gains beyond decomposition. The untrained FloWright, the reference of every gain in Tab. 1, already splits a bundled task into steps (9.74 per workflow on average at 4B) and aggregates their answers (Fig. 11). Over it, training improves accuracy by up to +5.03% at 4B (Tab. 1), and improves all 44 arms under every mode at 9B (Q6). Training also does not split tasks further: every trained 4B mode generates fewer steps per workflow (7.83-9.28) and a lower share of workflows with parallel branches (51.23-55.73% vs. 60.32%).

2. Gains with nothing to decompose. Each Decoy task holds a single question among decoy inputs (§D.1), unlike tasks that "bundle independently answerable sub-questions" (W2). On all 8 Decoy arms, the untrained FloWright still outperforms the single agent with tools and skills, by 6.96 at 4B and 12.03 at 9B on average, and every mode improves it further on all 8 arms at both sizes (Fig. 12, Q6). The benefits of FloWright therefore do not reduce to task decomposition, and we will add this analysis to §G.1.

Q6: Co-evolution at a larger model size

Thank you for your thoughtful question. We add the three co-evolution modes at 9B on all 44 test arms, and compare each with (a) generator-only training at the same model size (Q6 "whether the advantage of co-evolution over generator-only training also holds at a larger model size"). We summarize their overall accuracy (%) below:

Mode9BGain over (a), 4B (Tab. 1)Gain over (a), 9B
(b) agent-skill56.28+1.23+4.89
(c) upstream-downstream54.88+0.23+3.49
(d) multi-agent57.19+2.20+5.80

For every mode, the advantage over generator-only training is larger at 9B than at 4B, and each mode outperforms (a) at 9B on all 44 test arms.

References

[1] J. Zhang et al. AFlow: Automating Agentic Workflow Generation. 2025.

[2] G. Zhang et al. Multi-agent Architecture Search via Agentic Supernet. 2025.

Thank you for your valuable review and constructive feedback. We sincerely hope our response and clarifications above can meaningfully address your remaining concerns, and we will make sure to apply them to our revisions to further enhance our paper quality.

Thank you for the detailed response and the additional experiments. Most of my questions have been addressed, and I have raised my score.

One additional point I am curious about: each role improves when trained individually, yet combining the separately trained roles performs worse than the untrained workflow. A brief analysis of the failure modes in this combination would help clarify the benefit of co-evolution and the role of the mutual curriculum.

Comments on the paper

1 comment
AuthorsOpenReview ↗

Author Overall Response: Thank you for your valuable review and insightful feedback

Dear AC and Reviewers,

We sincerely thank you for your time, careful reviews, and constructive feedback. We are encouraged that Reviewer 1 (CCGv) and Reviewer 3 (CipM) recognize our unified approach to optimizing the roles that both construct and execute workflows, that Reviewer 2 (vLiD) recognizes our simple and role-agnostic reward design with deterministic validity terms and our motivation that the executing roles also need to learn, and that you (all Reviewers) recognize our broad evaluation and generalization across 44 arms, 12 datasets, and 7 domains.

Following your suggestions, we revise our paper as below:

  • Credit assignment, for Reviewer 2 (vLiD) W1: We state in §3.2 that the credit goes to the role's own nodes that root-cause an execution failure in the trace. We also restrict "no additional models, labels, or executions" in the abstract to localizing this credit. We further state in §E.3 and Tab. 4 that the helpfulness reward takes one additional execution.
  • Co-evolution setup, for Reviewer 1 (CCGv) W1+Q1+Q2, Reviewer 2 (vLiD) W2+Q2, and Reviewer 3 (CipM) W2: We update §3.4 and §4 (Setup) to state which roles co-evolve in each mode. We also state that each role keeps its own policy, and that all co-evolving roles learn from one shared set of rollouts. We further detail the training in §F.2.
  • Test-time distillation, for Reviewer 3 (CipM) W3: We show in §3.5 that the prior is distilled from the system's own workflows that execute to a final answer on earlier test tasks, with no label throughout the test-time optimization. We also state in §E.5 when the prior is fixed and how it changes across test tasks.
  • Consistent scoring, for Reviewer 2 (vLiD) W3 and Reviewer 3 (CipM) W4: We update both §4 and §G.1. We note how Decoy answers are scored in §4. We also validate the results in §G.1 under the partial credit that Shared and Paired already use.
  • New results, for all reviewers: We add the new comparisons and analyses in §5 and Appendix G.
  • §D.3 and §D.5, for Reviewer 2 (vLiD) W3 and Reviewer 3 (CipM) W3 / W4: We add the content audit to confirm that no test input file shares its content with a training file. Also, we also show DocFinQA's unused training split in Tab. 3, and clarify the InfoChartQA-Visual question counts across levels. We further state that Tab. 3 shows the data statistics after quality control applied.
  • §F.2, for Reviewer 1 (CCGv) W2+Q4, Reviewer 2 (vLiD) Q3, and Reviewer 3 (CipM) W1: We illustrate in detail how each single-agent baseline matches the budget of the corresponding workflow for each task. We also state how it reads the inputs and keeps the intermediate results in §F.2.
  • §G.1, for Reviewer 1 (CCGv) W2, Reviewer 2 (vLiD) W3, and Reviewer 3 (CipM) W1 / W4: We add the gains on domains that are never seen during training. We also show the gains on single-question Decoy tasks, and validate that 92% of the evaluated Decoy tasks are uniquely answerable. We further validate the results under partial credit, and add the gains on questions matched across levels.
  • §G.3, for Reviewer 1 (CCGv) W2+Q5, Reviewer 2 (vLiD) W2+Q2, and Reviewer 3 (CipM) W1: We add comparisons with existing workflow optimization methods, AFlow and MaAS. Both are matched with our pools, sandbox, budget, and run limits. We also add an adapted GEPA to compare test-time optimization.
  • §G.5, for Reviewer 1 (CCGv) W1+Q1+Q2 / W1+Q3 / Q6 / follow-up, Reviewer 2 (vLiD) W2+Q2, and Reviewer 3 (CipM) W2: We add the comparison of co-evolution against the same roles trained separately at comparable training compute. We further show the credit term ablation in every co-evolution mode. In addition, we add our new results for co-evolution with Qwen3.5-9B, and paired Wilcoxon tests over the 44 arms. Furthermore, we add the failure modes of the separately trained combination.
  • §G.6, for Reviewer 1 (CCGv) W2, Reviewer 2 (vLiD) Q1, and Reviewer 3 (CipM) W1: We add the accuracy among workflows that execute to a final answer. We also show how the workflow structure changes after training.

We sincerely thank you again for your valuable time and insightful feedback, which greatly strengthen the quality of our paper. We would be grateful if you could take these revisions into further consideration.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.