Dynamically-Decided MAS Architectures — Fable Review

1. Scope: what "dynamic" means here, and why the question matters

A multi-agent system (MAS) built from large language models (LLMs) is a set of model instances — each given a role prompt, and possibly tools — that exchange messages to solve a task together. Classical LLM-MAS frameworks (debate pipelines, MetaGPT-style software companies, fixed reviewer chains) hard-code who talks to whom, in what order: the communication structure is a fixed graph, usually a directed acyclic graph (DAG, a graph whose edges have direction and contain no cycles), drawn by a human before any query arrives. This review covers the research line that removes that human: systems in which the architecture — the communication graph, the team roster, or the entire workflow program — is learned, searched, generated, or adapted by an algorithm.

The question matters for two concrete reasons. First, accuracy: a fixed structure applies one design uniformly to every query, and several papers below show that matching structure to the individual query (a three-agent chain for an easy arithmetic problem, a dense reviewer graph for a hard one) yields measurable accuracy gains at fixed model quality. Second, cost: every edge in the communication graph is a prompt that must be re-encoded by the receiving agent, so structure directly determines token-processing cost. The pruning papers below report large savings — for example, AgentPrune reaches accuracy comparable to state-of-the-art topologies on MMLU (a 57-subject multiple-choice knowledge benchmark) at $5.6 of API cost versus $43.7 — which is the same objective, pursued at the text level, that KV-cache-level communication research pursues at the representation level.

The field also carries unusual momentum for its size. Among the 22 core papers verified here, the top-tier highlights (an "oral" is the small fraction of accepted papers selected for stage presentation; a "spotlight" is the next selective tier; the remainder present as posters) are: GPTSwarm (ICML 2024 Oral), AFlow (ICLR 2025 Oral), MDAgents (NeurIPS 2024 Oral), MaAS (ICML 2025 Oral), G-Designer (ICML 2025 Spotlight), ARG-Designer (AAAI 2026 Oral), and — as a boundary study — the failure-taxonomy paper MAST (NeurIPS 2025 Spotlight). Each of these tiers was confirmed against the venue's own pages, not press claims; the full evidence URLs are in the references.

How this review was produced. A multi-angle discovery sweep (96 raw candidates, 50 after de-duplication) was followed by per-paper extraction from arXiv full texts, and every extracted record was then re-checked by a separate adversarial verification pass that re-fetched sources and corrected or downgraded unsupported claims (11 of 22 records required corrections; all corrections are reflected here). Claims that survived only as "the paper says X, but the split is not disclosed" are reported with that caveat rather than silently accepted.

2. The two organizing questions: what is decided, and when

Reading the 22 core papers side by side, the clearest way to organize them is not by algorithm family but by two questions. The first is what the algorithm is allowed to decide — its design space. The observed spaces are: edge topology over a fixed agent pool (which pairs communicate); temporal edges (which messages cross from round t to round t+1); team composition (which agents exist at all); roles (what each agent is); workflow code (an executable program of LLM calls, the most expressive space); operator graphs (compositions from a fixed library of blocks such as Chain-of-Thought, reviewer, ensemble); prompts (usually co-optimized with structure); and termination depth (how many rounds to run).

The second question is when the decision happens, and it splits the field into three regimes with very different systems implications:

• Offline, per-domain. The structure is optimized once against a benchmark's training or validation split, then frozen; every test query flows through the same graph. GPTSwarm, AgentPrune, AgentDropout, ADAS, AFlow, AgentSquare, MASS, and SwarmAgentic belong to this regime. These methods automate design, but at deployment they are as static as a hand-drawn graph.
• Per-query at inference. A trained artifact — a graph generator, a router, a fine-tuned LLM — reads each incoming query and emits a bespoke structure before execution starts. G-Designer, MaAS, MAS-GPT, ScoreFlow, FlowReasoner, MasRouter, ARG-Designer, AMAS, and (with no training at all) MDAgents belong to this regime. This is the regime the phrase "dynamic MAS" usually intends.
• Per-round during execution. The structure changes while the system runs, in response to intermediate outputs: agents are dropped, added, or re-selected mid-episode. DyLAN's team reformation and early stopping, AnyMAC's step-by-step next-agent prediction, Puppeteer's per-step orchestrator policy, and EvoMAC's per-iteration network rewiring belong to this regime. This is the smallest and technically hardest regime.

The mechanism families cut across these regimes, and the master table below lists all 22 core papers along both axes. The table is a reference map, not the argument; each paper receives a full prose treatment in Sections 3–7, grouped by mechanism family, and the tags used in the table (for example "policy gradient", explained where first used) are introduced in those sections. Three reading conventions apply throughout: "REINFORCE" denotes the basic policy-gradient method of reinforcement learning (sample a discrete structure from a probability distribution, run it, score the outcome, and shift probability toward structures that scored well); unless stated otherwise, quoted results are accuracy percentages on the named benchmark; "pass@1" is the fraction of coding problems solved by the first generated attempt, and "F1" is the harmonic mean of precision and recall used for reading-comprehension tasks. "Tier n/a" means the venue does not publish oral/poster distinctions.

(Table content is kept in English; numbers and identifiers are verbatim from the report.)

(scroll right for more columns →)

Two reading aids for the table. "REINFORCE" is the basic policy-gradient algorithm of reinforcement learning: sample a discrete structure from a parameterized distribution, run it, score the outcome, and push probability mass toward structures that scored well — it appears in eight of the 22 papers because it is the standard way to optimize through a non-differentiable step (running LLM agents and grading their answer). "The same six as AgentPrune" refers to a benchmark set — MMLU, GSM8K, MultiArith, SVAMP, AQuA, HumanEval — that has become the de-facto shared harness of the topology-optimization line; Section 8 discusses why that monoculture is a problem.

3. Family A — learning a graph over a fixed agent pool

This family keeps the agents fixed and learns which edges to keep. It is the most direct formalization of "the topology is the variable", and it is where the lineage started.

GPTSwarm (Zhuge et al., KAUST/IDSIA; ICML 2024 Oral; arXiv 2402.16823). GPTSwarm represents each agent as a small computational graph of operation nodes (an LLM call, a tool invocation, a Tree-of-Thought expansion), and a society of agents as a composite graph joined by inter-agent edges. Every candidate edge i carries a continuous parameter θᵢ ∈ [0,1] read as an inclusion probability; sampling edges (skipping any that would close a cycle) yields a distribution over DAGs. The expected task utility — answer accuracy, or unit-test pass rate for code — is maximized by REINFORCE, with roughly M = 4–20 graphs sampled per iteration depending on the benchmark. Separately, an LLM "improver" rewrites each node's prompt from observed input-output failures. Both optimizations run offline per benchmark, and the frozen graph is then deployed. The evaluation used GPT-3.5-Turbo-1106 and GPT-4-Turbo (gpt-4-1106-preview) on four benchmarks: MMLU (a 153-question, 10% validation subset), Mini Crosswords (20 puzzles), HumanEval (164 coding problems), and the GAIA general-assistant benchmark (validation set, Levels 1–3). Headline results: crossword word accuracy 0.800 versus 0.668 for a Tree-of-Thought baseline; HumanEval pass@1 0.88 after optimization versus 0.76 before; GAIA Level 1 30.56 versus 20.75 for plain GPT-4-Turbo. The most cited demonstration is adversarial robustness: with 3 truthful and 3 deliberately-wrong agents, edge optimization learns to disconnect the saboteurs (0.8301 accuracy, versus 0.5751 for a debate baseline). Two caveats belong next to those numbers. The evaluation pools are small (20 crosswords; 153 MMLU questions), and optimization and evaluation draw from the same small pools, so overfitting-to-the-pool cannot be excluded. And on the adversarial MMLU table GPTSwarm does not actually beat DyLAN (0.8366) — its advantage there is cost, not accuracy: about $5.32 of optimization spend versus $105.93 for DyLAN's team optimization on the same setting.

AgentPrune ("Cut the Crap", Zhang et al.; ICLR 2025 Poster; arXiv 2410.02506). AgentPrune formalizes communication redundancy: in multi-round MAS dialogues, most messages do not change the outcome. It models one round as a spatial graph (who talks to whom within the round) and adjacent rounds as temporal edges (whose round-t message feeds whom at round t+1), and attaches a trainable continuous mask to every edge. The masks are trained for a short warm-up — only K′ of K rounds, on a small subset of queries — to maximize task utility minus a nuclear-norm penalty (a convex stand-in for low rank that pushes the mask matrix toward sparse structure), with gradients estimated by the same sample-and-score REINFORCE trick as GPTSwarm. Then comes the method's principal operation: a single one-shot magnitude pruning that keeps the top (1−p)% of edges, after which the sparse graph is frozen for all remaining queries. On the six-benchmark harness with five GPT-4 agents it matches or exceeds the accuracy of denser topologies (GSM8K 95.83% versus 90.23% for debate) while cutting 28.1–72.8% of prompt tokens; used as a plug-in on top of GPTSwarm it removes 60.6% of prompt tokens on GSM8K ($234.76 down to $57.17) while gaining 0.84 accuracy points. A limitation confirmed in verification: the paper never states the exact train/evaluate query partition per dataset, so the optimize-versus-report boundary is under-documented.

AgentDropout (ACL 2025 Long; arXiv 2503.18891). AgentDropout extends pruning from edges to agents. Both intra-round and inter-round adjacency matrices are made learnable (initialized at 0.5) and trained offline with REINFORCE on only 40 samples per dataset; then, per round, the agents with the smallest weighted degree are deleted (node dropout) before the weakest edges are cut (edge dropout, with a nuclear-norm term in the second phase's objective). The important framing difference from AgentPrune is that different rounds get different teams — the roster itself varies across rounds, though the whole schedule is fixed before deployment. Evaluated on the six-benchmark harness with open-weight backbones (Llama-3-8B, Qwen2.5-72B, DeepSeek-V3-671B), it averages 68.70 versus AgentPrune's 66.51 on Llama-3-8B, with 21.6% prompt-token and 18.4% completion-token reductions versus the state of the art. Train/test separation is clean (the 40 optimization samples are drawn from train or validation, not test), though "train or validation" is itself loosely specified.

AMAS (EMNLP 2025 Industry Track; arXiv 2510.01617) and the withdrawn DynaSwarm (arXiv 2507.23261). These two entries are best read together, and the relationship is a finding of this review's verification pass rather than something either paper states. DynaSwarm (submitted 2025-07-31, authors Hui Yi Leong and Yuqing Wu) trains a GPTSwarm-style edge distribution with A2C — an actor-critic variant of policy gradient that subtracts a learned value baseline to reduce gradient variance — checkpoints the training run, keeps the top K=4 sampled graphs as a candidate bank, and trains a LoRA head (a low-rank adapter of ~40.5M parameters, about 0.5% of the backbone) to score, per incoming query, which candidate graph to use. It was withdrawn by its lead author on 2025-08-12 citing a "content error". AMAS (seven authors, the same two leads among them) describes the same architecture — REINFORCE-trained candidate bank of K=4 graphs, LoRA rank-16 selector, pairwise ranking loss — and reports numbers on overlapping benchmarks and backbones that are nearly identical to DynaSwarm's (for example, Crossword on Llama-3-8B: 0.485 versus DynaSwarm's 0.483; latency 31.0s versus 30.9s). The reasonable reading is that AMAS is the corrected, published successor and DynaSwarm's numbers should be treated as superseded. AMAS's own protocol is comparatively disciplined — 8:1:1 train/dev/test splits on all five tasks — but its per-task margins over GPTSwarm (+0.01 to +0.04 absolute) are small against test sets as tiny as 25 crossword and 20 HumanEval items, so the margins are within noise range on the small tasks. One more correction from verification: AMAS is an EMNLP 2025 Industry Track paper, not Main-conference, which several secondary sources misreport.

4. Family B — generating a fresh graph for every query

Family A learns one graph and reuses it. This family trains a generator that reads the query and emits a topology before execution begins — the structural decision becomes query-conditioned.

G-Designer (ICML 2025 Spotlight; arXiv 2410.11782). G-Designer treats topology design as conditional graph generation. Agent profiles are embedded by a frozen sentence encoder (all-MiniLM-L6-v2, 384 dimensions); the query is embedded into a special task node wired to every agent; and a variational graph auto-encoder (VGAE — a graph neural network that encodes nodes into latent Gaussians and decodes pairwise edge probabilities) emits the adjacency matrix through a differentiable Gumbel-softmax edge sampler, refined by a nuclear-norm sparsification. Training maximizes REINFORCE-estimated task utility plus sparsity and anchor regularizers, on just 40 queries per benchmark; at inference every query gets its own graph, and harder queries visibly receive denser graphs. On the six-benchmark harness with gpt-4-1106-preview it posts the best average of its comparison field (MMLU 84.50%; HumanEval 89.90% pass@1) and its efficiency numbers are the strongest in the family: up to 95.33% token reduction on HumanEval versus the state of the art. Verification notes: this paper is the one whose ICML listing (labeled "Spotlight Poster" on the official virtual site) upgraded it from the preprint status most citation databases still show; and four of its six per-benchmark scores could not be pinned to the second decimal across independent reads of the table, so only the two abstract-confirmed numbers are quoted here.

ARG-Designer ("Assemble Your Crew", AAAI 2026 Oral; arXiv 2507.18224). Where G-Designer decides only edges over a fixed five-agent pool, ARG-Designer generates the graph from scratch, autoregressively: conditioned on the query, it emits the next agent's role (from an extensible role pool, via similarity to learned role embeddings — new roles can be added at inference without retraining), or an END token that fixes the team size; after each new node it predicts links to every earlier node. Training is supervised: maximize the likelihood of reference graphs collected by a dense-to-sparse curriculum (first learn from dense high-performing configurations, then fine-tune toward sparse token-efficient ones). With GPT-4o it sets the state of the art on all six harness benchmarks (MMLU 89.54%, AQuA 86.45%, HumanEval 91.74% — gains of +0.60 to +4.85 points over G-Designer) while using half of G-Designer's tokens on GSM8K (4.1M versus ~8.2M). The caveats: each dataset gets its own generator trained on only 40–60 queries, and the provenance of the "ground-truth" reference graphs (found by search against task scores) makes the supervision an implicit search signal whose construction details are thin in the paper.

AnyMAC (EMNLP 2025 Main; arXiv 2506.17784). AnyMAC abandons the graph representation entirely and rebuilds communication as a sequence: at each step, a small trained router (GPT-2-Small, 117M parameters — a deliberately cheap controller next to the GPT-4-class agents it routes) performs Next-Agent Prediction (which role speaks next, scored by inner product against role embeddings) and Next-Context Selection (which earlier outputs the speaker gets to read, via sigmoid gates). Because any step can read any prior output, a sequence with content-selection is strictly more flexible than a fixed DAG adjacency, at the cost of serializing the computation. The router is trained with REINFORCE on 80 questions per dataset; the reward multiplies correctness by γ^l, an exponential decay in realized path length l, so accuracy is explicitly traded against pipeline depth, and a sparsity penalty on the context gates does the same for reading width. On the six-benchmark harness it reports the best average (90.62%, +0.78 over G-Designer), and its efficiency variant claims a five-fold prompt-token reduction versus G-Designer on GSM8K. The verification pass flags that test-split sizes are unreported and train/test disjointness is not explicitly asserted.

MasRouter (ACL 2025 Main; arXiv 2502.11133). MasRouter widens the per-query decision beyond topology: a cascaded controller decides, in order, the collaboration mode (from a repository including chain-of-thought, Reflexion, self-consistency, and MacNet-style graphs), the agent roles (sequentially, from 26 predefined roles), and which LLM backbone runs each agent (from a pool of four commercial and open models). All three stages are variational modules over sentence-transformer embeddings, trained jointly by policy gradient on utility minus λ·cost. It averages 85.93 across five benchmarks, beating the best LLM-routing baseline by 3.51 points, and cuts HumanEval cost from $0.363 to $0.185; an inductive test shows it adopts a new, unseen model (DeepSeek-V3) at routing time and improves. The verification pass could not find a clear train/test split statement for four of the five datasets — the strongest hygiene concern in this family — and ACL provides no oral/poster tiers, so its tier stays unverified.

MDAgents (NeurIPS 2024 Oral; arXiv 2404.15155) is the family's untrained extreme, and evidence that query-adaptive structure does not require learning at all. A moderator LLM is prompted, zero-shot, to classify each medical query's complexity as low, moderate, or high; a fixed rule maps the label to one of three templates — a solo clinician, a discussing multi-disciplinary team, or a hierarchical pipeline of teams. There is no reward, no gradient, no search; the entire adaptivity is one classification prompt. Across ten medical QA/VQA benchmarks with GPT-4(V) and Gemini-Pro it achieves the highest result on seven (for example MedQA 88.7% versus 83.9% for the best fixed baseline), and — the important ablation — the adaptive selection (81.2% text-only average) outperforms every one of its own fixed structures applied uniformly (64.2–71.6%), while spending fewer API calls than a fixed heavy team (9.3 versus 20.3). It loses on three of the ten benchmarks, which the paper reports plainly. The oral tier is confirmed on the NeurIPS virtual site; the caveat is that evaluation uses subsampled test sets whose exact sizes the paper does not pin down.

5. Family C — searching the space of workflow programs

The graph families above fix what an "agent" is and vary the wiring. This family widens the space to executable code: the artifact being searched is a program that calls LLMs, so any prompting pattern, control flow, or tool logic is representable. The cost of that expressivity is that the search itself becomes the hard problem.

ADAS (Hu, Lu & Clune; ICLR 2025 Poster; arXiv 2408.08435) stakes the conceptual claim: because agent systems are code, a meta agent (GPT-4) can invent them by programming. Meta Agent Search keeps an archive seeded with classic designs (Chain-of-Thought, self-consistency, debate); each iteration, the meta agent reads the entire archive with scores, proposes an "interestingly new" design in natural language, implements it as a forward() function, self-debugs up to five times, and the evaluated result joins the archive. This is open-ended, evolution-flavored search with the LLM as the variation operator; the fitness is raw validation accuracy. Searched offline per domain (25–30 iterations) with discovered agents executed by the cheaper GPT-3.5, it outperforms hand-designed baselines everywhere tested — most strikingly reading-comprehension F1 79.4 versus 65.8 for the best hand-crafted baseline — and the discovered agents transfer: top MGSM-searched agents gain +25.9% on held-out GSM8K, and ARC-searched agents survive backbone swaps to Claude models. ARC uses an explicit 20-validation/60-test split, so hygiene is clean, though the searched domains are all narrow slices.

AFlow (ICLR 2025 Oral; arXiv 2410.10762) makes the code search systematic where ADAS is open-ended. A workflow is code over a small operator library (Generate, Review & Revise, Ensemble, Test, Programmer…); the search is a Monte Carlo Tree Search (MCTS — the explore/exploit tree algorithm from game-playing) whose tree nodes are complete workflows. Selection mixes uniform exploration with score-weighted softmax; expansion is an LLM optimizer (Claude-3.5-Sonnet) that rewrites prompts or edge code conditioned on the accumulated experience of past modifications and their outcomes; evaluation executes the child workflow five times on a deliberately high-variance validation subset; and results backpropagate into the experience store. Searched offline per benchmark on a 20% validation split (seed 42) and deployed frozen on the 80% test split, AFlow averages 80.3 across six benchmarks with a GPT-4o-mini executor — 5.7 points over the best manual baseline, 19.5 over ADAS under its harness — and its cost result is the line's most-cited efficiency figure: AFlow-discovered workflows let smaller models beat GPT-4o at 4.55% of its inference dollar cost. Hygiene is comparatively good (clean validation/test split), with subsampling caveats (HotpotQA/DROP at 1,000 samples; MATH restricted to a 617-problem level-5 subset).

AgentSquare (ICLR 2025 Poster; arXiv 2410.06153) narrows the code space to make search cheap: every agent is a combination of four standardized modules — Planning, Reasoning, Tool-Use, Memory — with uniform interfaces, abstracted from 16 published agents. Search alternates module recombination (an LLM proposes new combinations of existing modules) with module evolution (an LLM writes entirely new module code), and its distinctive trick is an in-context surrogate predictor that estimates a candidate's score from the experience pool at ~0.025% of the cost of a real evaluation, so only genuinely novel candidates get executed. Across six agentic benchmarks — embodied households (ALFWorld), science simulation, games, web shopping, travel planning, tool use, a deliberately different suite from the math/QA monoculture — it reports a 17.2% average gain over the best human designs on GPT-4o. The verification pass's most significant flag: the paper never clearly separates the split used for search from the split used for reporting, so optimize-on-test cannot be excluded from the text.

MASS ("Multi-Agent Design", Google/Cambridge; reported ICLR 2026, tier unverified; arXiv 2502.02533) contributes the ablation discipline the family lacked: it interleaves prompt and topology optimization in three stages — per-block prompt optimization first, then topology sampling from a space pruned by each block's measured influence, then a global prompt re-optimization on the winning topology — and its stage-wise ablation quantifies where the gains actually come from. On Gemini-1.5-Pro across eight tasks: base agent 63.54; +single-agent prompt optimization 67.44; +block-level prompt optimization 74.56; +topology optimization 77.55; +global prompt optimization 78.40. Read against the base-to-final spread, roughly three quarters of the improvement arrives through prompt optimization and about three points through topology — the clearest published evidence that prompts dominate topology in this design space, and a result that complicates topology-first interpretations of joint systems. Protocol is clean (disjoint 50–60-sample validation and 100–200-sample test splits per task), with the caveat that those test splits are small.

SwarmAgentic (EMNLP 2025 Main; arXiv 2506.15672) adopts the least conventional search algorithm: it transplants Particle Swarm Optimization — a population algorithm where candidate solutions move through the search space pulled by their own best past position and the population's global best — into language space. Each particle is a complete agentic system serialized as structured text (roles, responsibilities, policies, plus a step-to-agent collaboration structure); "velocity" is a set of edit operations (add/delete/modify/reorder) produced by LLM modules that combine a failure-driven repulsion term (avoid edits that failed before), a personal-best attraction, and a global-best attraction. With 5 particles and 10 iterations, optimized offline per task, it posts the family's largest relative gains on open-ended planning tasks — TravelPlanner 32.2 versus 8.9 for ADAS under a GPT-4o executor (+261.8% relative) — precisely the task type where code-as-workflow searchers are weakest. Split hygiene is explicitly handled (disjoint train/eval; leakage avoidance stated). The caveat is budget-shaped: five particles times ten iterations times full-system evaluation is a large hidden search bill that the paper does not convert into tokens or dollars.

6. Family D — training a model to be the architect

Family C searches per domain; each new domain pays the search again. This family amortizes: train a model once so that, at inference, it emits a bespoke structure in a single pass.

MAS-GPT (ICML 2025 Poster; arXiv 2503.03686) is the purest statement: MAS design as text generation. The training corpus pairs queries with complete executable MAS programs (agent prompts as variables, LLM calls as functions, interactions as string passing), built from a pool of 40+ re-implemented designs, scored by execution, then filtered for inter-consistency (similar queries mapped to similar strong designs) and intra-consistency (the design internally adjusted to the query, kept only if it does not score worse). Supervised fine-tuning of Qwen2.5-Coder-32B on the resulting 11,442 pairs (on 16 A100 GPUs) yields a generator that, given a query, writes reasoning plus a full runnable MAS in one forward pass — the paper prices this at roughly half an LLM call. With Llama-3-70B as executor it averages 65.47% across nine benchmarks versus 60.54% for the runner-up DyLAN, and it still helps frontier reasoning models (+13.34% for o1-preview on AIME-2024). Verification surfaced one internal inconsistency (the text claims a 3.89-point margin; its own table arithmetic gives 4.93) and one structural caveat: three of the nine "test" benchmarks (MATH, GSM8K, MMLU) also supply the training queries — different instances, same distributions — so the out-of-distribution story rests on the other benchmarks (GPQA, SciBench, AIME), where it indeed holds.

ScoreFlow (arXiv preprint 2502.04306) replaces supervised imitation with preference learning. An 8B generator (Llama-3.1-8B with LoRA) samples eight candidate workflows per problem; an executor scores each; and pairs of (better, worse) workflows train the generator with Score-DPO — a variant of Direct Preference Optimization (the standard method for training on preference pairs) modified to weight pairs by their numeric score gap and to rescale implicit rewards by the scores themselves, so a 95-versus-40 pair teaches more than a 61-versus-59 pair. Optimized offline per benchmark, the tuned generator emits a distinct workflow per query (a one-agent program for an easy GSM8K item, a program-plus-review pipeline for a hard one). It averages 85.3% across six benchmarks — +4.7 over AFlow under the same executor — with the notable inversion that its 8B generator outperforms the API-model generators used by ADAS/AFlow. Hygiene is clean (1:4 validation/test splits; the judge model is used only at final evaluation). Its ablation is one of the most useful in the field: on identical data, Score-DPO outperforms SFT, PPO, and vanilla DPO on every dataset, isolating the value of score-aware preference weighting.

FlowReasoner (arXiv preprint 2504.15257) pushes amortization to the query level with reasoning: a meta-agent is distilled from DeepSeek-R1 (SFT on ~1,400 reasoning-plus-MAS trajectories), then refined with GRPO — the group-relative policy-gradient method popularized by R1 — under a reward mixing solution pass rate, a code-complexity term, and a diversity term. At inference it reasons about the query, generates a personalized system, and refines it over ten execution-feedback iterations. FlowReasoner-14B reaches 81.89% across three coding benchmarks (+5.08 over MaAS; +10.52 over its own o1-mini worker used vanilla). The scope caveat matters: all three benchmarks are code generation, where execution feedback is cheap and reliable; nothing yet shows the recipe transfers to domains without a verifier. The RL contribution is real but modest (+1.6 points at 7B, +0.4 at 14B over SFT-only).

MaAS ("agentic supernet", ICML 2025 Oral; arXiv 2502.04180) sits between generator and searcher, borrowing the supernet idea from neural architecture search: instead of one architecture, maintain a parameterized probability distribution over architectures, and let each query sample its own. The supernet is a four-layer cascade of distributions over agentic operators (Chain-of-Thought, ReAct, debate, an early-exit operator, and so on); a lightweight controller reads the query embedding and autoregressively activates operators layer by layer, stopping early when the exit operator fires — so easy queries buy short cheap architectures and hard ones buy deep expensive ones. Training jointly updates the distribution (by a cost-regularized Monte-Carlo policy gradient whose importance weights explicitly reward architectures that are simultaneously correct and cheap) and the operators themselves (by "textual gradients": LLM-generated edits to prompts and operator structure from environment feedback). On five reasoning/coding benchmarks with gpt-4o-mini it averages 83.59% (best automated baseline AFlow: 82.25%) and tops GAIA's tool-use levels against agent-search baselines; its efficiency numbers are the family's best-documented — training cost $3.38 versus $22.50 for AFlow on MATH, inference at 6–45% of competitors' token cost. Verification confirmed the clean 1:4 train/test splits (Table 6) and the exact benchmark subsetting (MATH is a 617-problem level-5 subset — a detail that matters when comparing MATH numbers across papers).

7. Family E — deciding the structure while it runs

Everything above decides the structure before execution (per domain or per query). The last family re-decides during execution, which is where "dynamic" becomes literal.

DyLAN (COLM 2024; arXiv 2310.02170) is the earliest system in this review and still the reference point for runtime team management. It models collaboration as a temporal feed-forward network: agent i at round t is a node receiving the previous round's messages. Team selection happens offline but unsupervised: in a preliminary trial, each node LLM-rates its predecessors' contributions; the ratings propagate backward (an agent is important if important later agents relied on it), summing into an Agent Importance Score used to keep the top-k agents. At inference the structure keeps moving: after each round an LLM ranker keeps only top-ranked agents connected forward ("agent team reformation"), and a Byzantine-consensus-inspired rule (stop when more than two-thirds of a layer agrees) triggers early exit. There is no gradient anywhere — the optimizer is LLM-in-the-loop scoring. On HumanEval with GPT-3.5 it reaches 82.9 pass@1 versus 73.2 single-agent at 16.85 API calls (against 48 for the LATS search baseline); team optimization lifts single MMLU subjects by up to 25 points. Costs are reported in calls, not tokens or dollars. The paper's hygiene gap, confirmed on verification: how the preliminary-trial examples relate to the evaluation split is not documented.

Puppeteer (NeurIPS 2025 Poster; arXiv 2505.19591) makes the runtime decision a trained sequential policy. A centralized orchestrator — initialized, unusually, from a 70B reward model (Llama-3.1-Nemotron-70B-Reward) — selects, at every step, which of 13 agents acts next (five tool operators, eight reasoning operators, instantiable across a 15-model pool), conditioned on the evolving global state. REINFORCE trains it against a reward whose terminal term is correctness minus λ times accumulated cost and whose per-step cost grows logarithmically with step count — so the policy learns when to stop spending as much as whom to call. The reported evolution is the interesting part: over RL training the orchestrator's induced graphs become more compact and more cyclic (revisiting agents rather than fanning out), with cost falling while accuracy rises (Titan subspace average 0.7731 evolved versus 0.6893 at initialization, against AFlow's 0.6899). The caveat is protocol opacity: instance counts and the train/evaluate boundary for the RL episodes are not explicit in the text.

EvoMAC (ICLR 2025 Poster; arXiv 2410.16946) brings the update inside a single task. Aimed at software development, it maintains a coding team and a testing team, both DAGs of prompt-parameterized agents. Each iteration: the coding team writes code; the testing team generates unit tests; the compiler runs them; a "gradient agent" converts failures into textual gradients (which agent's subtask failed, what is missing); and an "updating agent" edits the network — revising prompts, removing done agents, adding missing ones, rewiring edges. This is textual backpropagation: the chain rule replaced by natural-language attribution. On its self-built software benchmark (rSDE-Bench, 53 tasks with requirement-level tests) it leads every split (for example Website-Basic 89.38% versus 62.90% single-agent), and on HumanEval reaches 94.51% with GPT-4o-Mini. The structural caveat is inherent to the design and the verification pass states it directly: the same unit tests that drive the textual gradients also define the reported accuracy, so the method optimizes on its evaluation signal for each task. For rSDE-Bench the tests are requirement-derived (partly auto-generated, manually corrected), which softens but does not remove the circularity; the HumanEval numbers use the benchmark's own hidden tests as target proxy generated by the testing team, a cleaner setting.

Family E also includes the runtime edge of the tier-B frontier — Captain Agent's per-step team rebuilding inside nested conversations, AgentNet's fully decentralized DAG where each agent rewires its own outgoing edges from local expertise and retrieval memory (NeurIPS 2025), and TacoMAS's test-time co-evolution of capability (fast loop) and topology (slow loop) — described in Section 9.

8. Evaluation practices and their limits

The reported claims of this field are accuracy-and-cost claims, so the evaluation settings deserve the same scrutiny as the algorithms. Reading all 22 verified records together, five patterns stand out.

A repeated benchmark set, inherited by citation. Eight of the 22 core papers (AgentPrune, G-Designer, AgentDropout, AnyMAC, ARG-Designer, and with small variations MasRouter, AMAS, MaAS) evaluate on the same six benchmarks — MMLU, GSM8K, MultiArith, SVAMP, AQuA, HumanEval — five of which are grade-school-to-college QA/math sets that frontier single models already saturate. Within the monoculture, method deltas are often within a point or two (AnyMAC 90.62 average versus G-Designer 89.84), and MultiArith/SVAMP sit above 92% for nearly everyone. The suites that actually separate methods are the agentic ones — GAIA (tool use), ALFWorld/ScienceWorld/WebShop (embodied and web tasks, AgentSquare), rSDE-Bench (software), TravelPlanner (constraint planning, where absolute scores are still in the single digits to low thirties) — and only a minority of papers use them.

Small optimization sets, presented as a strength. The topology learners optimize on remarkably little data: 40 queries (G-Designer, AgentDropout), 40–60 (ARG-Designer), 80 (AnyMAC), 153 (GPTSwarm's MMLU subset). This is genuinely a strength for the sample-efficiency story — a topology that transfers from 40 examples is cheap to obtain — but it makes the reported deltas fragile: several margins over baselines are of the same magnitude as the noise implied by test sets of 20–254 items (AMAS's crossword test set is 25 puzzles; its margin over GPTSwarm there is 0.017–0.038 absolute).

Split opacity is the norm, not the exception. Of the 22 core papers, the verification pass judged the train/test protocol clean and explicit for AFlow, MaAS, ScoreFlow, MASS, ADAS, ARG-Designer, AgentDropout, SwarmAgentic, and AMAS; it found the boundary under-documented or unstatable for GPTSwarm (optimization pools overlapping tiny evaluation pools), AgentPrune (partition unstated), AgentSquare (search-versus-report split unclear), MasRouter (no split statement for four of five datasets), AnyMAC (disjointness not asserted), DyLAN (trial-versus-test relation undocumented), Puppeteer (RL episode provenance), FlowReasoner (training-item origin), and structurally circular for EvoMAC (optimizes on the test signal by design). MAS-GPT sits in between (distribution overlap between training-query sources and three test benchmarks, with clean OOD sets alongside). This is not an accusation of misconduct anywhere; it is a documentation standard the field has not yet adopted.

Cost accounting is selective. The papers optimizing for cost report it well (MaAS's full token/dollar/wall-clock table; AgentPrune's dollar comparisons; MasRouter's Pareto fronts; AFlow's 4.55%-of-GPT-4o figure). But search cost is often left out of the headline: AFlow's 20 MCTS rounds times 5 validation executions, SwarmAgentic's 5×10 full-system evaluations, and ADAS's 25–30 meta-iterations are paid before the first efficient inference, and only MaAS and GPTSwarm price the optimization phase explicitly ($3.38 and $5.32 respectively on their settings). For per-query generators the amortization argument is sound — MAS-GPT's half-a-call overhead is genuinely cheap — but the field lacks a standard "total cost to first useful deployment" metric.

Backbone fragmentation quietly shapes conclusions. The six-benchmark line standardized on gpt-4-1106-preview or gpt-4o-mini; the generator line mixes small open generators with API executors; AgentDropout is open-weight only; Puppeteer spans 15 models. Cross-backbone transfer, where tested, is encouraging (MaAS's supernet transfers from gpt-4o-mini to Qwen-2.5-72B; ADAS's agents survive GPT-3.5-to-Claude swaps; SwarmAgentic's systems transfer across five executors), but no study holds the method set fixed while varying backbones systematically — so "method A exceeds method B" claims are, strictly, claims about one backbone.

A final observation worth carrying into any comparison: MASS's staged ablation (Section 5) implies that a large fraction of what looks like "topology gain" in joint systems is actually prompt gain. Papers that optimize topology while keeping prompts fixed (the pruning line) and papers that co-optimize both (GPTSwarm, MaAS, MASS, SwarmAgentic) are answering different questions, and comparison tables that mix them inherit the confound.

9. The frontier and the boundary (verified tier-B corpus)

Beyond the 22 deep-dive papers, 27 further works were existence- and venue-verified with mechanism summaries. They matter for seeing where the field is moving in 2026; this section groups the notable ones, and the reference list carries the rest. Three currents are visible.

The generative-model current: topology synthesis as conditional generation. Guided Topology Diffusion (ACL 2026 Main) and RADAR (ICML 2026) both generate communication graphs by discrete graph diffusion — an iterative denoising process, guided step-by-step by proxy reward predictors (accuracy/cost for GTD, a redundancy measure for RADAR) — replacing the one-shot VGAE decoding of G-Designer with multi-step, redundancy-aware construction. GoAgent (preprint) generates topology at the granularity of groups rather than nodes, with an information-bottleneck objective compressing inter-group messages. The current's direction is clear: topology generation is becoming a proper conditional-generation problem with multi-objective guidance, not a pruning afterthought.

The RL-stabilization current. Graph-GRPO (preprint) imports group-relative advantage estimation (GRPO) into topology learning — sampling a group of graphs per query and computing edge-level advantages within the group — to attack the reward-variance problem that plain REINFORCE suffers on binary task rewards. W4S (COLM 2025) trains a 7B "weak" meta-agent by RL to write workflows harnessing frozen strong executors (2.9–24.6% over the strongest baseline across eleven benchmarks, with ~1 GPU-hour of training). An RL-orchestration survey (preprint 2605.02801) formalizes the whole space as reward-design × credit-assignment × orchestration-decisions over "orchestration traces", and observes that message-level counterfactual credit is the missing tool almost everywhere.

The test-time current. TacoMAS (preprint) co-evolves capability (fast loop) and topology (slow loop) online; MAS-on-the-Fly (preprint) assembles a per-query system by retrieval from a repository of successful collaboration patterns, with a watcher agent intervening at runtime; SafeSieve (AAAI 2026) prunes edges progressively across runs, blending semantic heuristics into accumulated experience; SID (ICLR 2026 submission) drives debate participation from the models' own internal confidence and attention signals, with no external controller; ARMOR-MAD (preprint) gates debate rounds on agreement thresholds, training-free. Difficulty-aware orchestration (DAAO, WWW 2026) conditions workflow depth and per-node model choice on a learned difficulty estimate — the same easy-query-cheap-structure logic as MaAS's early-exit operator, now made explicit.

Boundary works that calibrate the field. MacNet (ICLR 2025 Poster) is the static control: scaling hand-specified topologies to 1,000+ agents, finding irregular graphs beat regular ones and a logistic "collaborative scaling law" — evidence that topology matters, from outside the learned-topology program. MAST ("Why Do Multi-Agent LLM Systems Fail?", NeurIPS 2025 Spotlight) annotates 1,000+ execution traces into a 14-mode failure taxonomy (41.8% specification/design failures, 36.9% inter-agent misalignment, 21.3% verification failures) — the empirical justification for why structure, roles, and termination need optimizing at all. Optima (ACL 2025 Findings) is the sharpest orthogonal contrast: it fixes the topology and trains the agents' communication behavior (iterated SFT/DPO on a reward balancing performance, token count, and readability; up to 2.8× performance at less than 10% of the tokens) — deciding what agents say rather than who talks to whom. A position paper (2505.22467) and a workflow-optimization survey (2603.22386) argue the "when is structure decided" axis is the field's proper organizing principle, which this review's Section 2 independently adopts.

One tier-B verification correction worth recording: the widely-circulated citation "Dynamic Generation of Multi-LLM Agents Communication Topologies with Graph Neural Networks" is mistitled — the actual ACL 2026 paper at arXiv 2510.07799 uses conditional graph diffusion, not a GNN, and is titled accordingly ("…with Graph Diffusion Models", GTD).

10. What the field agrees on, and where it is genuinely unsettled

Sections 3–9 presented systems and their evaluations individually; this section separates the conclusions that hold across families from the questions the current evidence cannot resolve.

Points of convergence. First, moderately sparse structures match or outperform dense ones: every pruning and generation paper, plus the causal analysis of information propagation (EMNLP 2025), finds moderately sparse topologies match or exceed fully-connected ones at a fraction of the tokens — error suppression outweighs lost diffusion. Second, query-adaptivity pays when query difficulty varies: MDAgents' ablation (adaptive 81.2% versus best-fixed 71.6%), MaAS's early-exit economics, and DAAO's difficulty conditioning all show the gain comes from not overspending on easy queries. Third, the cost axis has become co-equal with accuracy: post-2024 papers almost uniformly carry an explicit cost term (λ·C in MaAS/MasRouter/Puppeteer, γ^l in AnyMAC, nuclear norms in the pruning line), which is a real change in the field's objective function. Fourth, small controllers suffice: GPT-2-Small (AnyMAC), a VGAE (G-Designer), a LoRA head (AMAS), MiniLM embeddings plus an FFN (MaAS) — the structural decision is orders of magnitude cheaper than the agents it steers.

Points of genuine disagreement. Whether learned topology outperforms strong hand design remains unsettled: on the six-benchmark harness the learned methods' margins over the best fixed graphs are typically 1–4 points with the caveats of Section 8, and MASS's ablation attributes most joint-system gain to prompts. Whether the right target is a graph at all: AnyMAC's sequence framing, Puppeteer's per-step policy, and MAS-GPT's whole-program generation each dissolve the adjacency matrix in different directions, and nothing yet adjudicates between them on common ground. Whether per-query generation is worth its machinery against a well-chosen static portfolio: FlowBank's precompute-and-reuse (+4.26 over automated baselines by matching into a workflow bank) suggests a cheap middle path the head-to-head literature has not absorbed. And the least settled question — whether any of this survives against one stronger single model at equal total cost — is addressed only by scattered baselines (PHP, a strong single-agent prompting method, appears above several MAS systems in the six-benchmark tables), never yet by a dedicated equal-budget study within this line.

11. Implications for KV-cache-level agent communication research

This final section relates the surveyed literature to research on serving-tier agent communication — reusing and repairing attention state (the KV cache: the per-token key/value tensors a transformer accumulates while reading a context) across agents, rather than re-encoding text. The dynamic-architecture literature has four direct consequences for that research space, stated here as objective observations.

First, the decision-timing taxonomy is exactly a KV-reusability taxonomy. Offline-static systems (Family A after pruning, Families C's frozen outputs) fix the communication pattern across all queries, so agent-pair KV channels are stable, precomputable, and amortizable — the most favorable regime for cross-agent prefix reuse. Per-query generators (Family B, D) randomize the pattern at every query: which agent reads which agent's output is unknown until the generator runs, so KV-reuse machinery must either condition on the emitted graph (reactive) or be integrated into the generator's objective (proactive). Per-round systems (Family E) are hardest: the reader set of a message is decided after the message exists, which forecloses any precomputation and makes incremental, lineage-tracked KV handoff the only viable design.

Second, sequential cascades are structurally compatible with KV reuse, and the field is drifting toward them. AnyMAC's next-agent chain, Puppeteer's one-agent-per-step policy, and MaAS's layer-by-layer sampling all serialize communication into a growing single context — precisely the monotone-prefix pattern that KV-cache handoff exploits best (one lineage, no cross-branch merging). By contrast, dense spatial graphs force many-to-one context assembly, the case where naive KV concatenation is known to fail and repair mechanisms (position re-alignment, selective recompute) are required. The dynamic-topology literature has, for its own token-cost reasons, been sparsifying and serializing MAS communication — pushing the workload toward shapes where representation-level communication is most tractable.

Third, every cost-aware objective in this literature prices tokens, and none prices the serving tier. MaAS's C(G;q), MasRouter's λ·C, Puppeteer's logarithmic step cost, AnyMAC's γ^l all count tokens or calls; none distinguishes a token that hits a warm prefix cache from one that forces a cold prefill, and none models transfer cost of moving cached state between agents on different workers. A topology objective whose cost term is serving-aware — rewarding structures whose communication pattern maximizes prefix-cache hits or minimizes KV transfer volume — is an unclaimed, well-posed extension: the optimization machinery (policy gradient over structures against a scalar cost) is already standard in eight of the papers above, and only the cost model needs replacing.

Fourth, the evaluation gap of Section 8 is an opening for systems work. No paper in this corpus reports time-to-first-token, prefill/decode breakdowns, or cache behavior; "cost" is an API bill. A study that holds the model fixed, holds the harness fixed, and measures dynamic-versus-static topologies at the serving tier — including the KV-reuse patterns each topology family admits — would provide evidence that the accuracy-oriented venues above do not currently report; the field's own trajectory — sparsification, serialization, cost-awareness — steadily increases the relevance of such a study.

12. Verification appendix

Twenty-two core records were extracted from primary sources and independently re-verified; eleven required corrections (GPTSwarm, MaAS, G-Designer, MAS-GPT, ScoreFlow, MasRouter, ARG-Designer, MDAgents, AMAS, SwarmAgentic, DynaSwarm — the largest were venue upgrades from stale preprint status, tier downgrades where evidence pages did not show the claimed tier, and number pinning against tables). All accepted tiers rest on the evidence URLs below; ACL/EMNLP/COLM/IJCAI/WWW do not publish oral/spotlight distinctions in their public records, so papers at those venues carry "tier n/a" rather than a guessed tier. DynaSwarm's numbers are reported for the historical record only (withdrawn by its lead author on 2025-08-12 citing a content error; superseded by AMAS from the same group). Items that could not be pinned to primary evidence are marked as such in the text (MASS's ICLR 2026 tier; four of G-Designer's six table numbers).

Core references (arXiv ID; venue; tier evidence)

• GPTSwarm — 2402.16823; ICML 2024 Oral — icml.cc/virtual/2024/oral/35447
• DyLAN — 2310.02170; COLM 2024 — arXiv PDF header + comments
• MDAgents — 2404.15155; NeurIPS 2024 Oral — neurips.cc/virtual/2024/poster/96041
• ADAS — 2408.08435; ICLR 2025 Poster — proceedings.iclr.cc (2025 paper 36b7acf6…)
• AFlow — 2410.10762; ICLR 2025 Oral — iclr.cc/virtual/2025/oral/31731
• AgentSquare — 2410.06153; ICLR 2025 Poster — openreview.net/pdf?id=mPdmDYIQ7f
• AgentPrune — 2410.02506; ICLR 2025 Poster — iclr.cc/virtual/2025/poster/29978
• G-Designer — 2410.11782; ICML 2025 Spotlight — icml.cc/virtual/2025/poster/45567
• MaAS — 2502.04180; ICML 2025 Oral — icml.cc/virtual/2025/session/46894 (Oral 1A "Alignment and Agents"; the paper's own virtual page 44335 carries the "Spotlight Poster" label that ICML 2025 gives oral papers' poster slots)
• MAS-GPT — 2503.03686; ICML 2025 Poster — icml.cc/virtual/2025/poster/46543
• ScoreFlow — 2502.04306; arXiv preprint
• FlowReasoner — 2504.15257; arXiv preprint (OpenReview submission)
• EvoMAC — 2410.16946; ICLR 2025 Poster — iclr.cc/virtual/2025/poster/31011
• AgentDropout — 2503.18891; ACL 2025 Long — aclanthology.org/2025.acl-long.1170
• AnyMAC — 2506.17784; EMNLP 2025 Main — aclanthology.org/2025.emnlp-main.584
• MASS — 2502.02533; ICLR 2026 reported, tier unverified
• MasRouter — 2502.11133; ACL 2025 Main — aclanthology.org/2025.acl-long.757
• Puppeteer — 2505.19591; NeurIPS 2025 Poster — neurips.cc/virtual/2025/poster/118584
• ARG-Designer — 2507.18224; AAAI 2026 Oral — github.com/Shiy-Li/ARG-Designer + ojs.aaai.org/index.php/AAAI/article/view/39481
• AMAS — 2510.01617; EMNLP 2025 Industry — aclanthology.org/2025.emnlp-industry.144
• SwarmAgentic — 2506.15672; EMNLP 2025 Main — aclanthology.org/2025.emnlp-main.93
• DynaSwarm — 2507.23261; withdrawn arXiv preprint (v2, 2025-08-12)

Tier-B references (existence/venue verified)

The list below records, for each frontier or boundary paper discussed in Section 9, its arXiv identifier and the venue status that survived verification; "preprint" means no acceptance could be verified as of 2026-07-20. Mechanism summaries for these papers appear in Section 9.

AutoAgents 2309.17288 (IJCAI 2024); Captain Agent 2405.19425 (preprint); EvoFlow 2502.07373 (preprint); AgentSwift 2506.06017 (AAAI 2026); W4S 2504.04785 (COLM 2025); Heterogeneous Swarms 2502.04510 (NeurIPS 2025); AgentNet 2504.00587 (NeurIPS 2025); SafeSieve 2508.11733 (AAAI 2026); DAAO 2509.11079 (WWW 2026); GTD 2510.07799 (ACL 2026 Main — graph diffusion, not GNN); GoAgent 2603.19677 (preprint); Graph-GRPO 2603.02701 (preprint); RADAR 2605.09907 (ICML 2026); TacoMAS 2605.09539 (preprint); AgentConductor 2602.17100 (preprint); MAS-on-the-Fly 2602.13671 (preprint); FlowBank 2606.11290 (preprint); ARMOR-MAD 2606.13197 (preprint); SID 2510.06843 (ICLR 2026 submission); Optima 2410.08115 (ACL 2025 Findings); Information-Propagation/EIB-Learner 2505.23352 (EMNLP 2025); MetaFlow 2606.30704 (preprint); MacNet 2406.07155 (ICLR 2025); MAST 2503.13657 (NeurIPS 2025 Spotlight); Topology-position paper 2505.22467 (preprint); Workflow-optimization survey 2603.22386 (preprint); RL-orchestration survey 2605.02801 (preprint).