acceptodds
Under review as a conference paper at ICLR 2027

FRAME: Failure-Aware Multi-Agent Topology Learning with Random Fourier Features

Abstract

Large language model (LLM)-based multi-agent systems (MAS) increasingly rely on learned collaboration topologies to coordinate specialized agents efficiently. Yet, existing topology optimizers remain largely task-conditioned: they construct topology from the task and predefined role capabilities, while overlooking evidence revealed during execution and providing limited mechanisms to recover when the resulting collaboration fails. To mitigate this drawbacks, we introduce FRAME (Failure-Aware Multi-Agent Topology Learning with Random Fourier Features), a failure-aware, execution-conditioned framework that unifies topology construction and repair through bilevel optimization. At the upper level, FRAME learns the collaboration graph autoregressively, conditioning each decision on the task, selected roles, and evolving execution states. Specifically, FRAME introduces Random Fourier Feature Upper Confidence Bound (RFF-UCB) role selection, combining nonlinear utility estimation with uncertainty-aware exploration, while communication edges are learned using a lightweight neural network optimized directly from task reward. When performance falls below a prescribed threshold, the lower level localizes the source of underperformance and performs targeted role repair, which is subsequently fed back into topology construction. This design turns topology learning from a one-shot graph prediction problem into a closed-loop process of constructing, executing, diagnosing, and repairing. Across diverse benchmarks, FRAME consistently outperforms the existing topology design algorithms while being token efficient.

Primary area:
foundation or frontier models, including LLMs
Keywords:
LLM Multi-Agent Systems, Topology Learning, Autoregressive Graph Generation, Failure-Aware Repair, Random Fourier Features

Reviews

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

This paper proposes FRAME, an algorithm that progressively selects agent roles and generates a communication structure based on the question and the agents' intermediate outputs, ultimately building a complete multi-agent structure. The method uses RFF-UCB to select roles and a lightweight neural network to decide which edges to connect. When the constructed multi-agent structure cannot complete the task, it uses interventional verification to identify the problematic role, modifies its prompt, and reconstructs the graph. Effective role repairs obtained during training are saved and reused. The authors evaluate the method on eight benchmarks, including code generation and mathematics.

Critical strengths
  1. Adjusting subsequent roles and communication between agents based on actual problem-solving results is a meaningful direction. Earlier outputs can help determine which agents to select next and how the agents should collaborate. The ablation results in Table 3 support using intermediate outputs to guide graph construction.

  2. The experiments cover multiple tasks, and the main experiments use one open-source model and one closed-source model. The proposed algorithm also achieves noticeable improvements on MMLU-Pro and LiveCodeBench.

Critical weaknesses
  1. Insufficient reporting of the training procedure and full training costs

    In the proposed algorithm, each time a new node is added, the current partial graph needs to be executed again on the current training question. According to the paper, each training question undergoes three graph-construction runs. At each construction step, three edge configurations are sampled, and each configuration is executed three times. If failure repair is triggered, additional correction and graph reconstruction are required. This training procedure involves a large number of repeated model calls. However, the paper does not report the token consumption and wall-clock time of the full training process on each benchmark, nor does it compare training costs with other baselines. The authors need to report these results and specify the number of concurrent API requests so that it is possible to assess whether the performance gains from the additions to the algorithm are worth the corresponding training costs.

    In addition, although the paper provides the procedure and sampling counts for a single question during training, it does not report the total number of epochs, the total number of parameter updates, or when the overall training procedure ends. These details also need to be provided.

  2. Issues with the experimental statistics; the sources of the HumanEval training and test sets also need to be explained

    The average number of nodes and the proportion of single-agent graphs in Table 11 do not match. For GSM8K, the single-agent proportion is 88.3%, and every remaining graph contains at least two nodes, so the minimum average number of nodes should be 1.117, rather than the reported 1.07. The same issue occurs for HumanEval: its single-agent proportion is 89.0%, and the maximum number of nodes is five, so the average number of nodes can be at most 1.44, below the reported 1.48. If these numbers come from the same set of final topologies, they cannot hold simultaneously. The authors need to explain this issue.

    In addition, Table 8 reports 40 training questions and 164 test questions for HumanEval, but the standard HumanEval dataset contains only 164 questions in total. The source of the 40 training questions therefore needs to be explained. If these 40 questions were sampled from the full set of 164 questions and the same 164 questions were then used for testing, the training and test sets would overlap. The authors need to clarify this issue and explain where the training data come from, as this directly affects the validity of the experimental results.

Questions for authors
  1. What are the total training token consumption and wall-clock time for the proposed algorithm and the main comparison baselines on each benchmark? Do these statistics include all calls for candidate graph execution, interventional verification, role modification, and graph reconstruction? What is the number of concurrent requests when calling the models?

  2. What are the complete training details for each benchmark? How many epochs are used in total, how many parameter updates are performed in total, and what is the condition for ending training?

  3. How are the average number of nodes and the proportion of single-agent graphs in Table 11 calculated? Do the two columns come from the final topologies of the same set of test instances? Based on the single-agent proportions in Table 11 and the node-count limits in the paper, the average number of nodes should be at least 1.117 for GSM8K and at most 1.44 for HumanEval, which do not match the reported 1.07 and 1.48. How should these discrepancies be explained?

  4. Where do the 40 training questions for HumanEval come from? Are the 164 questions used for testing the full standard HumanEval dataset?

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

This paper proposes a failure-aware framework for learning LLM multi-agent collaboration topologies, which mainly constructs a collaboration graph using Random Fourier Feature Upper Confidence Bound (RFF-UCB) role selection. Experiments across reasoning and coding benchmarks show improved task accuracy and token efficiency.

Critical strengths
  1. This paper addresses an important problem of topology failures in multi-agent systems, with a reasonable motivation for adapting to intermediate agent outputs.

  2. The proposed method combines incremental topology construction and provides a practical approach to improving multi-agent collaboration.

Critical weaknesses
  1. The paper presentation needs to be significantly improved for conceptual clarity. While "failure" is the major issue this paper targets, it is not sufficiently explained or defined, e.g., the types, levels, and other characteristics of failures. The introduction lists several limiations, it is not clear which mechanism solves which limitation. The paper introduces multiple concepts that are mathematically formulated but not adequately justified in terms of their operational meaning. I also recommend replacing some mathematical definitions of methods from other papers with more conceptual descriptions and justifying the design choices, rather than focusing too much on precise definitions.

  2. It is unclear whether the token efficiency improvement arises from the improved multi-agent topology optimization or the adaptive termination mechanisms, with an additional inference-time judge model for terminating topology construction. Moreover, results from multiple runs are important for demonstrating performance comparisons with other baselines in MAS, where agents' decisions can diverge heavily in different runs.

Questions for authors

See weaknesses.

Reviewer_y1QvOpenReview ↗
Rating
1
Confidence
4
Informativeness
1
Presentation
1
Soundness
1
Read review
Paper summary

This paper proposes FRAME, a framework for execution-conditioned multi-agent topology construction and failure-aware role repair. FRAME selects roles using RFF-UCB and determines communication edges through a learned policy, conditioning subsequent construction on intermediate agent outputs. During training, targeted interventions identify and repair deficient roles; validated repairs are stored in a skill bank for reuse at inference. Experiments cover reasoning, mathematics, and code generation benchmarks.

Critical strengths

A useful integration of topology construction and failure recovery.

FRAME allows intermediate outputs to influence subsequent role and edge selection, rather than committing to the complete collaboration graph before execution. The skill bank also provides a mechanism for transferring validated role repairs to unseen tasks.

Encouraging results on challenging benchmarks.

With Qwen3-8B, FRAME substantially outperforms the strongest reported baselines on MMLU-Pro and LiveCodeBench. The ablations separately examine execution-state conditioning, nonlinear role selection, and lower-level repair. The paper also states that baselines share the same backbone, initial role pool, and role descriptions.

Critical weaknesses

1.Evidence on challenging tasks is limited, particularly for the efficiency claim.

Several Table 1 benchmarks are near saturation, making MMLU-Pro and LiveCodeBench the most informative evaluations. However, both are evaluated only with Qwen3-8B, without corresponding GPT-4o results. Complete inference-token comparisons are also missing for these two benchmarks; efficiency results on GSM8K and HumanEval do not establish the same tradeoff when more collaboration and repair may be required. Moreover, all three learned-topology baselines fall below Vanilla on MMLU-Pro, while FRAME improves substantially, but this contrast is not systematically analyzed.

2.Operational details and diagnostics are insufficient to fully assess and reproduce the framework.

The appendix provides useful prompts, but does not fully specify several consequential settings, including role-selection and edge-policy hyperparameters, skill-bank retrieval thresholds and limits, and execution reuse during topology expansion. On the two challenging benchmarks, the paper also lacks agent-count distributions, role-selection frequencies, and cumulative model-call statistics. Skill-bank diagnostics cover only MMLU-Pro, while the qualitative examples show graph changes without complete agent outputs or the actual role revisions. These omissions make it difficult to understand how FRAME operates in practice and which mechanisms account for its gains.

3.The design of agent role pool lacks sufficient justification. Why do we need these? Are they comparable with other baselines? Are they used to hack the benchmarks?

Overall, I don't see the proposed method as proven reasonable. I would suggest that the authors substantially revise the paper.

Questions for authors
  1. Can the authors provide GPT-4o results and complete inference-token comparisons against the main baselines on MMLU-Pro and LiveCodeBench, including judge, verification, repair, and re-execution calls?

  2. Why do AgentPrune, G-Designer, and ARG-Designer underperform Vanilla on MMLU-Pro? Please analyze the regression and clarify the baseline configurations and tuning protocol.

  3. For both challenging benchmarks, please report agent-count distributions, role-selection frequencies, average edge counts, and cumulative model calls. Please also provide skill-bank sizes, retrieval coverage, and recovery success rates, distinguishing retrieval events from unique test instances.

  4. Please clarify the role-pool development procedure and provide the complete hyperparameter and execution configurations, including skill retrieval and output caching. A complete execution example for each challenging benchmark, showing agent outputs, stopping decisions, and any role repair, would substantially improve clarity.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.