Dynamically-Determined Graphs and Workflows — Sol Review

Executive summary

The literature does not use “dynamic topology” consistently. At least three objects are called an architecture: (a) the directed message graph among persistent agents, (b) the membership and roles of the team, and (c) the executable workflow of LLM calls, tools, branches, loops, and aggregators. They have different systems implications. This report therefore includes all three, but labels the object being selected and treats AgentSquare, MacNet, and Optima as boundary controls. The core corpus is 22 dynamic-design systems; with those three controls, 25 papers receive full treatment.

The strongest answer to the research question is not simply “more papers than GPTSwarm, AgentPrune, and MaAS.” It is that at least three timing regimes must be separated:

O — offline/domain-adaptive: one graph or program is optimized on a benchmark/domain and reused. GPTSwarm, AgentPrune's multi-query mode, AgentDropout, ADAS, AFlow, MASS, and SwarmAgentic are in this class. They automate architecture design, but are not query-adaptive at deployment. Q — query-adaptive: the query selects or generates a fresh team/graph/workflow before execution. G-Designer, AGP, ARG-Designer, CARD, MaAS, MAS-GPT, ScoreFlow, and DynaSwarm's selector do this. The selected graph normally remains fixed during its dialogue. T — turn-adaptive: membership, edges, code, or stopping can change after observing intermediate messages or environment feedback. DyLAN, AnyMAC, AgentNet, DySCo, FlowReasoner, EvoMAC, and AutoAgents provide different versions. This is the smallest and most systems-relevant group.

Two-axis taxonomy

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

Mechanistically, GPTSwarm is REINFORCE over Bernoulli edge-existence probabilities in a composite operation-node DAG; AgentPrune learns real-valued spatial/temporal masks with policy-gradient utility and low-rank regularization, then prunes once; MaAS has a controller sample a query-conditioned subarchitecture from an agentic supernet and updates it with cost-aware score-function gradients while textual gradients mutate operators. Later work expands the design space: ARG-Designer autoregressively generates both roles and edges; ScoreFlow trains an LLM to emit query-specific executable workflow code; FlowReasoner revises such code against feedback; AnyMAC learns who acts next and which previous messages that agent reads; EvoMAC literally inserts, removes, and reconnects coding agents between rounds.

The empirical picture is promising but less settled than headline tables suggest. Dynamic methods often beat other multi-agent baselines by 1–6 percentage points and can cut prompt tokens by 20–90%. Yet comparisons frequently use an inexpensive single backbone, count inference but not architecture-search cost, omit topology-selection overhead, or optimize on small/nonstandard slices of public benchmarks. GPTSwarm's crossword and HumanEval experiments and DyLAN's main team selection inspect the evaluation corpus; several newer papers do not disclose enough split provenance to exclude leakage. Strong single-agent methods sometimes remain competitive (for example PHP versus G-Designer). Consequently, the credible conclusion is conditional: adaptive sparse computation can improve a given weak-to-medium backbone under a particular budget, not that MAS is universally superior to one stronger model.

Master comparison

The table below is the report's one-line-per-paper index. Columns give the design object and mechanism, the O/Q/T timing class defined in the executive summary, the evaluation benchmarks, the principal backbone models, and the venue with its verified presentation tier.

Timing abbreviations are O, Q, and T as defined above; “Q+T” means an initial query-specific design that can subsequently change.

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

(scroll right for more columns →)

I. Edge learning, pruning, and explicit graph generation

This part covers the systems whose decision variable is the communication graph itself. Each entry reports the decision mechanism, the evaluation setup, and the venue with tier evidence.

1. GPTSwarm — Zhuge et al. (2024)

1. Decision mechanism. The search space is a composite DAG whose vertices are operation nodes inside and between agents; internal agent graphs are fixed and candidate cross-agent edges are independent Bernoulli variables. Cyclic samples are rejected. Monte-Carlo REINFORCE estimates the gradient of expected task utility with respect to edge probabilities; Adam updates them. A separate LLM/UCB prompt optimizer can rewrite node prompts. Optimization is offline per benchmark. A graph may be sampled per instance from the learned distribution, but its probabilities do not depend on that query.

2. Evaluation. On an adversarial MMLU setting (gpt-4-1106-preview, three truthful/three adversarial debaters), 153 validation items followed a development optimization; GPTSwarm reached .8301 at $5.32 optimization/$1.82 inference versus DyLAN .8366 at $105.93/$14.99. Seven truthful agents improved direct answering by 2.1±1.1 points. Mini Crosswords used gpt-3.5-turbo-1106: edge optimization .465→.575 and node optimization →.668; the same 20 puzzles were optimized and evaluated. HumanEval repeatedly fed the entire set to the online prompt optimizer (.76→.88), another clear optimize-on-test concern. GAIA used 165 validation examples and a hand-built, rather than learned, swarm. Baselines include debate, DyLAN, single agents, and fixed graphs.

3. Venue + tier. ICML 2024 paper, Poster, verified by the official ICML program.

2. AgentPrune (“Cut the Crap”) — Zhang et al. (2025)

1. Decision mechanism. Nodes are whole role agents; separate real-valued masks describe same-round spatial messages and previous-to-current-round temporal messages. Spatial samples are projected to DAGs. A policy-gradient estimator maximizes nondifferentiable task utility, while nuclear-norm regularization encourages low-rank adjacency and a Frobenius term discourages large perturbations. After K′ initial rounds (single-query mode) or Q′ early queries (multi-query mode), the top-K mask magnitudes survive and the graph is frozen. It is one-shot pruning, not a permanently rewiring controller; “trainable low-rank mask” means nuclear-norm regularized, not explicitly low-rank-factorized.

2. Evaluation. Five agents, gpt-4-1106-preview (temperature 1; also gpt-3.5-turbo-0301), two rounds for general/math and four for code; MMLU, GSM8K, MultiArith, SVAMP, AQuA, HumanEval. Complete-topology AgentPrune averaged 89.72 versus GPTSwarm 86.77 and debate 87.01. Raw prompt-token examples are MMLU 3.06M→0.99M and HumanEval 2.74M→0.75M relative to GPTSwarm, with similar accuracy; the abstract gives 28.1–72.8% savings. MMLU uses development/first-153 validation separation, but other scripts optimize on the early ordered stream and cumulative reporting includes those early items; exact subsets are under-specified.

3. Venue + tier. ICLR 2025, Poster.

3. AgentDropout — Wang et al. (2025)

1. Decision mechanism. A fixed five-role pool receives a separate intra-round and inter-round adjacency matrix at each time. Stage 1 uses Bernoulli DAG sampling and REINFORCE on 40 optimization items, ranks agents by weighted degree, and drops a fraction α. Stage 2 reinitializes the smaller graph, optimizes expected accuracy minus a nuclear-norm sparsity penalty, then retains the top 1−β edge fraction. Roles/prompts are fixed. Despite “dynamic” in the title, the final round-varying topology is learned once per domain and reused.

2. Evaluation. MMLU, GSM8K, AQuA, MultiArith, SVAMP, HumanEval with Llama-3-8B-Instruct, Qwen2.5-72B-Instruct, or DeepSeek-V3-671B-Instruct; five-agent, fully connected initialization. Against AgentPrune, average scores were 68.70 versus 66.51 (Llama), 91.58 versus 90.81 (Qwen), and 93.72 versus 93.25 (DeepSeek). Average Llama prompt/completion totals fell from AgentPrune's 4.2M/1.0M to 3.3M/0.839M; the paper aggregates +1.14 score, −21.6% prompt, −18.4% completion. The 40 items are said to come from training or validation, suggesting held-out evaluation, but dataset-to-split mapping, final sizes, and hyperparameter-selection data are not reported.

3. Venue + tier. ACL 2025 Long Paper, Poster, verified by the conference presentation page.

4. DynaSwarm — Leong et al. (2025)

1. Decision mechanism. [unverified — withdrawn v1] A2C replaces GPTSwarm's REINFORCE on a 12-operation-node ToT/reflection/output graph: a product-Bernoulli actor samples composite DAGs, a neural critic predicts utility, and advantage updates actor and critic. Checkpoints yield four candidate graphs. A LoRA-tuned query/candidate ranker then selects one candidate per test query. Thus topology learning is O and deployment is Q-selection among four fixed choices, not free generation or turn rewiring.

2. Evaluation. [unverified — withdrawn v1] The surviving v1 names 5×5 Crossword, Game of 24, MMLU, BBH, and HumanEval (despite saying seven tasks), using GPT-3.5 [snapshot unreported], Llama-3-8B/70B, DeepSeek-R1-Distill-7B and a Qwen2.5-3B pilot. It uses a 12-node ToT/reflection system; external tools and subset sizes are unreported. Against GPTSwarm, Llama-3-8B gains were 0.9–3.6 points across five tasks with essentially unchanged average latency (30.6 versus 30.9 seconds); no token/cost accounting is given. Main text asserts train/dev/test separation, but the motivational pilot inspected 15 crossword test cases. Model-size and task-count inconsistencies remain.

3. Venue + tier. arXiv:2507.23261 was withdrawn for a content error. All v1 methods/results above are historical and [unverified]; no venue tier applies.

5. G-Designer — Zhang et al. (2025)

1. Decision mechanism. Five role/tool-profile agents and the query virtual node are embedded by MiniLM and a two-layer GCN/VGAE. A task-conditioned Logistic-Concrete edge decoder forms a dense sketch; low-rank factorization with reconstruction, anchor-graph, and nuclear-norm losses yields a sparse directed graph. Task utility supplies REINFORCE over 10 graph samples on 40 or 80 optimization queries. At inference the frozen GNN generates a new graph once per query; roles and three-round graph stay fixed.

2. Evaluation. gpt-4-1106-preview; MMLU 153, GSM8K 1,319, MultiArith 600, SVAMP 1,000, AQuA 254, HumanEval 164. Average accuracy was 89.84 versus GPTSwarm 87.32 and DyLAN 85.64; strong single-agent PHP was 88.17. On GSM8K, training+inference used about 8.5M tokens versus GPTSwarm 14M. A 20-node gpt-3.5-turbo-0125 MMLU run achieved 77.82 with 1.85M prompt tokens versus GPTSwarm 75.38/30.32M. Baselines also include fixed chain/star/tree/complete/random, AutoGen, MetaGPT, debate, CoT/SC. The paper says optimization items are removed before testing, but its “#Test” totals, provenance, and random seeds make the nonstandard split ambiguous.

3. Venue + tier. ICML 2025, Spotlight Poster, verified by the ICML program.

6. AGP — Adaptive Graph Pruning

1. Decision mechanism. AGP first searches a 16-agent complete heterogeneous “anchor” pool: roughly 2,000 sampled subgraphs/orders are executed and the top two retained, producing 460 query–node-mask–edge-matrix triples. A Sentence-BERT query/role/tool encoder and two-layer GCN then jointly predict a node mask (MLP/BCE-focal loss) and directed edges (bilinear head/MSE), with sparsity/coherence penalties and annealed Gumbel-Sigmoid. Threshold 0.5 gives a variable team and graph in one pass per query. It is supervised imitation of expensive graph search, not inference-time pruning or RL.

2. Evaluation. gpt-4o-mini [snapshot unreported], three communication rounds, with an appendix gpt-3.5-turbo [snapshot unreported] study; a variable subset of the 16 role/tool-profile agents is selected. MMLU 153, GSM8K 1,319, MultiArith 600, SVAMP 1,000, AQuA 254, HumanEval 164. AGP averaged 91.04 versus G-Designer 89.56, with baselines MaAS, GPTSwarm, DyLAN, AgentPrune, MacNet, AgentVerse, MetaGPT, debate, CoT/SC. Reported prompt reductions versus G-Designer include 65% on GSM8K (+1.04 points), 67% on SVAMP (+5.28), and 22% on HumanEval (+3.12); MMLU used about 0.25M tokens, claimed 90% below GPTSwarm. The source splits for the 460 labels and relation to reported test queries are not identified, so leakage cannot be excluded.

3. Venue + tier. ECAI 2025 Main acceptance is on the official list. “Spotlight” is author/project-page claimed but not found in that list: tier [unverified].

7. ARG-Designer — Li et al. (2026)

1. Decision mechanism. ARG-Designer factorizes a DAG probability into autoregressive role choices and incoming-edge Bernoullis. A query-conditioned node GRU selects roles by metric learning against their MiniLM text embeddings (plus END, allowing an extensible role pool); an edge GRU samples links from prior nodes. Supervised teacher-forcing loss weights node/edge NLL 0.2/0.8. Training graphs first come from successful resource-rich templates on 40/60 base queries, then from manually checked minimal graphs, successful node/edge deletion, and replay. Correctness and efficiency therefore enter through curation, not an explicit RL cost objective. Each query gets a fresh role set/DAG, fixed for three rounds.

2. Evaluation. gpt-4o-2024-08-06; generated role count varies until END and external tools are unreported. MMLU 153, GSM8K 1,319, AQuA 254, MultiArith 600, SVAMP 1,000, HumanEval 164. ARG averaged 92.78 versus G-Designer 90.04 and debate 87.53; GSM8K prompt tokens were about 4.1M, roughly half G-Designer. Baselines also cover single/CoT/SC, fixed graphs, AgentPrune and AgentDropout. The efficiency curriculum cut GSM8K tokens 6.25M→4.1M. Paper totals are labelled test, but removal of the 40/60 training queries is unclear; repository HumanEval indices (40 train, 121 test) conflict with the paper's total 164. Held-out accounting is unresolved.

3. Venue + tier. AAAI 2026, Oral, verified in AAAI's main-track oral schedule.

8. CARD — Conditional Agentic Graph Designer

1. Decision mechanism. CARD embeds each agent's base model, role, tool, availability, cost/API reliability/tool quality, and the query virtual node. Graph encoders operate over an anchor topology; a pairwise decoder produces directed edge probabilities. The stated loss is negative API-measured task utility plus β times expected edge cost and is described as gradient-trained through the soft graph; because discrete task accuracy is nondifferentiable and no estimator/surrogate is specified, that gradient path is under-specified. At inference a new query/condition vector re-decodes the graph without retraining. It is Q-adaptive and can react when external conditions change, but the decoded graph stays fixed for the ordinary K-round execution.

2. Evaluation. Five domain roles, HumanEval, MATH, MMLU; training/testing with GPT-4o-mini, DeepSeek-V3, and Llama-3-70B, plus OOD GPT-4o and Qwen2.5-72B (API snapshots unreported). Domain tools are supported, but exact main-run role/tool assignments are not stated. CARD scored 90.50/74.50/86.67, compared with best cited baselines AFlow 89.83/73.83 and G-Designer 84.44 on MMLU, winning or tying 13 of 15 model/task settings. Baselines include single/CoT, random, debate, GPTSwarm, AFlow and G-Designer. A condition-aware graph added about 0.5–3 points over static CARD; cost plots are not numerically tabulated. Dataset counts, optimization split, and training hyperparameters are insufficiently reported, a substantial reproducibility/hygiene limitation.

3. Venue + tier. ICLR 2026, Poster.

II. Supernets, routers, and turn-adaptive communication

This part covers controllers that pick or assemble the structure at query time or during execution. The same three-field format applies to each entry.

9. MaAS / Agentic Supernet — Zhang et al. (2025)

1. Decision mechanism. The supernet has four layers of reusable operator nodes (LLM prompt/model/tool operations). A controller combines a MiniLM query embedding with operator embeddings and samples operators without replacement until a cumulative activation threshold; END supplies early exit. Consequently nodes, depth, calls, and induced edges vary per query. Four sampled trajectories estimate a cost-aware score-function/policy gradient for utility minus λ token cost. In an outer loop, LLM textual gradients mutate prompts, temperatures, and node structure. Learning is offline on training queries; subarchitecture selection is Q-adaptive, not message-adaptive.

2. Evaluation. Custom 1:4 train:test splits: HumanEval 33/131, MBPP 86/341, GSM8K 264/1,055, MATH 119/486 (the prose/table totals conflict), MultiArith 150/600, GAIA 94/372. Main executor gpt-4o-mini-2024-07-18; transfer Qwen2.5-72B-Instruct and Llama-3.1-70B. Across the first five, MaAS averaged 83.59 versus AFlow 82.25 and vanilla 77.50; reported inference reduction is 6–45%. On MATH, MaAS 51.82 cost $3.38 search/$0.42 test versus AFlow 51.28/$22.50/$1.66. Baselines include ADAS/AFlow, GPTSwarm, DyLAN, debate, AgentPrune and strong prompting. The split is held out, though custom randomization seeds and the MATH count conflict are unresolved.

3. Venue + tier. ICML 2025, Oral, verified by the official oral session (also displayed as a spotlight poster).

10. DyLAN — Liu et al. (2024)

1. Decision mechanism. DyLAN unfolds agents as a temporal feed-forward network. Preliminary trials assign peer ratings; a backward Agent Importance Score from final consistent answers selects a task/domain team. During a new problem, an LLM listwise ranker at the middle layer keeps the top two active nodes, deleting other downstream communication, and consensus enables early stopping. Team selection is normally O; rank/prune and stop are T. This is not learned continuous adjacency.

2. Evaluation. gpt-3.5-turbo-0301 (WebShop -1106), transfer gpt-4-0613; selected pools were General Reasoning 7→4, Code Generation 12→8, Decision Making 8→4, and Arithmetic Reasoning 4→4; four general/six code layers. HumanEval 164: 82.9 with 16.85 calls versus single 73.2 and LATS 81.1/48 calls; GPT-4 transfer 92.1. WebShop 50: reward 68.3, success 42%, 24.85 calls versus direct 50.6/28%/14.52. MMLU downsampled 1/5 of test problems across all 57 subjects: 70.5/4.39 calls versus single 66.4 and debate 69.3/12. Full MATH: with CoT, DyLAN 35.7 versus single 31.6; with ComplexCoT prompting, DyLAN 37.6 versus single 34.1 (PHP 36.5). Selection cost is excluded. Main team selection evaluates the same dataset later reported; MATH skips selection. Treat main gains as optimize-on-evaluation.

3. Venue + tier. COLM 2024, Poster; the official accepted list has no oral/spotlight marker.

11. AnyMAC — Wang et al. (2025)

1. Decision mechanism. AnyMAC represents collaboration as a sequence in which agents can recur. At every step, a GPT-2-small router uses MiniLM embeddings of query, candidate roles, and history. Its next-agent policy chooses a role via inner products/Gumbel-Softmax; a context selector independently gates any previous message with sigmoid-cosine Bernoullis. REINFORCE optimizes γ^length times correctness with a difficulty-normalized advantage and optional gate sparsity; maximum length is five. Both who speaks and which prior KV-bearing text is exposed are T decisions.

2. Evaluation. Five-role maximum, GPT-4-1106-preview workers; MMLU 153, GSM8K 1,319, MultiArith 600, SVAMP 1,000, AQuA 254, HumanEval 164. AnyMAC averaged 90.62 versus G-Designer 89.84, with rows 84.30/95.66/99.44/92.67/81.50/90.12. Baselines include prompting, fixed chain/star/tree/complete/random, AutoGen, debate, DyLAN, GPTSwarm and G-Designer. The efficient variant restricts context to the newest two messages and reports about 5× fewer GSM8K prompt tokens than G-Designer, without an exact aggregate accuracy/cost table. Each dataset trains on 80 questions/1,000 routing trajectories; where no train split exists it uses the first 80 test items, an explicit optimize-on-test concern.

3. Venue + tier. EMNLP 2025 Main; presentation tier [unverified].

12. AgentNet — Yang et al. (2025)

1. Decision mechanism. Each decentralized agent has a router, executor, separate retrieval memories, and a capability vector. On each turn it chooses forward, split, or execute and routes by task–capability similarity while a visited set forms a per-query path/DAG. Across tasks, edge weights combine an EMA success prior and current routing success, are pruned below a threshold, and capabilities/memories update. This is heuristic/LLM-prompted T routing plus cross-query graph evolution, with no policy gradient.

2. Evaluation. Three agents; DeepSeek-V3, gpt-4o-mini, Qwen-turbo [API snapshots unreported]. Custom splits were MATH 700/140 across seven types, BBH 627/100 across 20 tasks, API-Bank random 100/100 with GPT-4o-mini type annotations. In [MATH, BBH, API-Bank] order, AgentNet scored DeepSeek 92.86/94/30, GPT-4o-mini 85/86/29, Qwen 81.43/92/32. Baselines direct, ReAct, Synapse, SC, Self-Refine, MorphAgent, MetaGPT, AFlow, GPTSwarm. The evolution ablation uses [MATH, API-Bank, BBH] order and rises 77.86/23/76→85/32/86. No token savings are reported. Splits are disjoint, but API sampling seed and contamination controls are under-described.

3. Venue + tier. NeurIPS 2025, Poster.

13. DySCo — Dynamic Sparse Consensus

1. Decision mechanism. Six agents first answer independently. Every round, each receiver scores potential senders by trust, self-reported confidence, reasoning divergence, role dependency, and token cost with weights .30/.20/.25/.15/.10, then reads top-k=2 compressed messages. Trust updates by EMA from verification/agreement. Weighted-consensus entropy below ε=.30 or two-round answer stability triggers early exit (maximum R=3). It is a training-free, genuinely T-varying directed graph; weights are hand-set heuristics rather than learned.

2. Evaluation. Random 300-item subsets each of GSM8K, LogiQA and StrategyQA, gpt-3.5-turbo [snapshot unreported], six agents, means over three seeds. Against dense debate, DySCo scored 84.3/78.5/85.4 versus 82.0/76.8/83.5, while mean tokens per query were 4.5k/5.0k/3.8k versus 14.8k/16.2k/12.4k; mean latency example 9.8 versus 18.6 seconds. Baselines also include single CoT, SC(6), static ring, random-k and trust-only sparse. There is no training split, but no validation or provenance for heuristic/hyperparameter tuning either; possible test tuning cannot be assessed.

3. Venue + tier. arXiv:2606.01828, preprint; venue/tier [unverified].

III. Search, generation, and evolution of workflow programs

This part covers systems whose design space is executable workflow code rather than a graph over fixed agents. The same three-field format applies to each entry.

14. ADAS — Automated Design of Agentic Systems

1. Decision mechanism. Meta Agent Search uses gpt-4o-2024-05-13 as an LLM programmer over arbitrary sub-100-line Python forward programs: prompts, roles, FM calls, control flow, tools, and hence workflow topology may all change. At each offline domain iteration it reads an archive of code and validation scores, proposes a novel idea/program, self-reflects twice, repairs runtime errors up to five times, evaluates task score, and archives it. This is open-ended, heuristic code search (25 ARC/30 other iterations), not RL; the best program is fixed at test.

2. Evaluation. ARC easy grids ≤5×5 used 20 validation/60 test, five runs; gpt-3.5-turbo-0125 executor with code execution: 13.7±3.9 versus best seed CoT-SC 8.0±3.2. DROP, MGSM, MMLU used 128 validation/800 test; GPQA Diamond 32/166. ADAS scored 79.4/53.4/69.6/34.6, generally above CoT/SC, Self-Refine, debate, Quality-Diversity, OPRO and role assignment. Transfer used claude-3-haiku-20240307, gpt-4o-2024-05-13 and claude-3-5-sonnet-20240620; search cost about $500 ARC/$300 per other domain. Search consumes validation only, but authors repeatedly evaluate every discovered agent on test and plot test over iterations, creating test-inspection/presentation-selection risk.

3. Venue + tier. ICLR 2025, Poster. Earlier workshop distinctions are not the main-paper tier.

15. AFlow — Zhang et al. (2025)

1. Decision mechanism. Each MCTS node is executable workflow code: LLM operators (Generate, Review/Revise, Ensemble, Test, Programmer, Custom) plus branches, loops, parallelism, prompts and edges. Claude-3.5-Sonnet-0620 chooses from top candidates/root, reads score deltas and execution traces, and rewrites code/prompts. Each candidate runs five validation trials; scores and textual experience backpropagate; stop at stable top three or 20 rounds. Model/temperature/format are mostly fixed. Objective is task metric; this is LLM-guided MCTS offline per benchmark, not a trained controller.

2. Evaluation. Full GSM8K/HumanEval/MBPP, random 1,000 HotpotQA/DROP, and 617 level-5 MATH items in four categories; seed-42 20% validation/80% test, test repeated three times. Executors DeepSeek-V2.5, gpt-4o-mini-2024-07-18, claude-3-5-sonnet-20240620, gpt-4o-2024-05-13. Workflows have variable operator-call nodes rather than a fixed role-team count and may use Programmer/code-test operators. On mini, AFlow averaged 80.3 versus best manual CoT-SC 76.0 (+4.3 points; 5.7% relative) and ADAS 67.2. HumanEval was 94.7 at $0.0513 for the test set; a DeepSeek execution transferred from the mini workflow achieved 93.90 at $0.0291 versus GPT-4o IO 93.89/$0.6371. Search cost is excluded. Held-out, but a nonstandard re-split of public benchmark sets.

3. Venue + tier. ICLR 2025, Oral.

16. ScoreFlow — Wang et al. (2025)

1. Decision mechanism. A Llama-3.1-8B-Instruct generator maps each raw query to unique executable worker code drawn from an operator library with prompts, branches and loops. Offline, three iterations sample eight workflows per validation query, execute them with GPT-4o-mini, and form winner/loser pairs. Score-DPO samples pairs proportional to cubed score gap and rescales implicit chosen/rejected rewards by their quantitative scores; LoRA trains on 2,000 pairs per dataset (HumanEval 600). At test, code is generated once Q-wise; no turn rewiring.

2. Evaluation. Full HumanEval/MBPP, GSM8K official test 1,319, random 1,000 DROP/HotpotQA, and level-5 MATH [count unreported], randomly re-split 1:4 validation:test; test three repeats. The variable workflow uses GPT-4o-mini [snapshot unreported] operator workers and programmer/test tools, not a fixed role-team count. ScoreFlow averaged 85.3 versus AFlow 80.6 (+4.7 points), with 86.0/86.2/95.9/84.7/94.6/64.4. Baselines IO, CoT/SC, MedPrompt, debate, Self-Refine, ADAS, AFlow; Qwen2.5-7B generator and GPT-4o/DeepSeek workers [snapshots unreported] are transfer tests. Search cost was $2.257 versus AFlow $4.608 on mini, while HumanEval inference was slightly dearer ($0.2281 versus $0.2021). Method says held-out validation; a table caption says optimization on test data, an unresolved documentation inconsistency.

3. Venue + tier. arXiv:2502.04306, preprint; accepted venue/tier [unverified].

17. FlowReasoner — Gao et al. (2025)

1. Decision mechanism. DeepSeek-R1-671B supplies about 1,400 traces in which a meta-agent reasons, emits query-specific workflow code using six AFlow operators, executes visible unit tests, and revises. DeepSeek-R1-Distill-Qwen-7B/14B receives three-epoch SFT then GRPO: five rollouts, up to five episodes, reward from pass rate, AST complexity and workflow diversity; later-round normalized rewards become token advantages. At inference it generates/executes/refines up to ten iterations, so both Q graph generation and T code/topology adaptation occur.

2. Evaluation. BigCodeBench, HumanEval and MBPP [versions/counts/splits unreported]; variable operator workflows use visible unit-test/code tools rather than a fixed role count. Default o1-mini workers, with Qwen2.5-Coder-32B, Claude-3.5 and GPT-4o-mini transfer [snapshots unreported]. The arXiv-v1 table gives 14B 63.53/97.26/92.15 and paper-reported Overall 81.89 versus MaAS Overall 76.81 (+5.08); Overall is not the arithmetic mean. Baselines include single, Self-Refine, debate, Blender, AutoAgents, ADAS and AFlow. No token/$ table. Training traces are “sourced from” these same benchmarks without disclosed query separation; visible per-query tests also give privileged feedback. This is a major unresolved contamination issue. A later OpenReview manuscript adds ScoreFlow; numbers here follow arXiv v1.

3. Venue + tier. arXiv:2504.15257, no verified main archival acceptance. Poster at the verified ICML 2025 “Multi-Agent Systems in the Era of Foundation Models” workshop; ICLR/TMLR records are submissions/review, not acceptances.

18. MAS-GPT — Ye et al. (2025)

1. Decision mechanism. MAS-GPT is Qwen2.5-Coder-32B-Instruct SFT to emit an entire executable Python MAS per query—agents, roles, prompts, model/tool calls and communication/control edges. Data construction evaluates a 40+ MAS pool on query–system pairs, retains correct systems, clusters similar queries and chooses the highest cumulative-score system; GPT-4o-2024-11-20 refines agent definitions and creates reasoning, retained only if no worse. The resulting 11,442 pairs/7,580 unique systems train three epochs. Inference uses one generator call; no search or adaptation after code generation.

2. Evaluation. Training: MATH 6,000; GSM8K 1,000; GSM-Hard 319; AQuA-RAT 1,000; MBPP 374; SciQ 2,000; MMLU 1,529. Tests: MATH/GSM8K/GSM-Hard 500 each, HumanEval/HumanEval+ 164 each, GPQA 448, SciBench 500, MMLU 500, AIME-2024 30. Executors Llama-3-70B-Instruct, Qwen2.5-72B-Instruct, gpt-4o-mini-2024-07-18, o1-preview-2024-09-12, DeepSeek-R1. With Llama, 65.47 average versus next SC 61.58; AIME gains +13.3 points with o1 and +10 with R1. Ten baselines include CoT/SC, debate, Self-Refine, SPP, AgentVerse, GPTSwarm and DyLAN. No numeric token/cost table. Sampling/overlap assurance, especially GSM-Hard, is insufficiently documented.

3. Venue + tier. ICML 2025, Poster.

19. MASS / Multi-Agent Design — Google Research

1. Decision mechanism. MASS searches counts of Aggregate {1,3,5,7,9}, Reflect/Debate/Summarize {0…4}, and binary Execute blocks under a ten-agent budget, with a fixed operator ordering. First MIPRO optimizes each block prompt and estimates influence. Softmax influence scores then guide pruning/rejection sampling of ten configurations; each is validated three times. Finally MIPRO optimizes the complete workflow prompts. Objective is validation task metric; cost is a hard budget rather than reward term. The result is one O architecture per task, not a learned Q generator.

2. Evaluation. Validation/test: MATH 60/100, DROP 60/200, HotpotQA/MuSiQue/2WikiMQA 50/100 each, MBPP 60/200, HumanEval 50/100, LiveCodeBench test-output 100/200. Gemini-1.5-Pro-002 and Flash-002, transfer Claude-3-5-Sonnet-20240620 and Mistral-Nemo-12B. Against CoT, SC@9, Self-Refine, 3×3 debate, ADAS and AFlow, MASS averaged 78.79 versus debate 70.26/ADAS 69.72 on Pro, and 74.30 versus 65.91/64.75 on Flash. MATH-Flash achieved 81.0 at $5.09 search/$0.0014 per inference versus AFlow 64.3/$3.89/$0.0006. Held-out protocol is explicit; code tasks, like AFlow, may use public tests as executor feedback.

3. Venue + tier. ICLR 2026, Poster.

20. SwarmAgentic — Zhang et al. (2025)

1. Decision mechanism. A particle is a complete executable team: variable agents with roles/responsibilities/policies plus ordered workflow steps and dependencies. Five particles run ten offline iterations. For each, an LLM diagnoses agent and collaboration failures; a language-space PSO “velocity” merges failure memory, personal-best difference and global-best difference, then add/delete/modify/reorder operations change agents, prompts, steps, edges and generated Python. Fitness is training-set task score. It returns one global-best system per benchmark; it is not Q- or T-adaptive at deployment.

2. Evaluation. TravelPlanner (9 representative search/180 evaluation), Natural Plan Trip/Meeting/Calendar (8/10/10 training; disjoint difficulty-matched 10% evaluation), Creative Writing first 5/remaining 95, MGSM 128/800. gpt-4o-mini-2024-07-18 optimizer; gpt-3.5-turbo-0125, gpt-4o-2024-08-06, claude-3-5-sonnet-20240620, DeepSeek-V3, Gemini-1.5-Pro executors. Final team size varies and is unreported; generated workflows can assign task-specific tools. Versus Direct, CoT, Self-Refine, SPP, EvoAgent and ADAS, GPT-4o TravelPlanner final pass was 32.2 versus ADAS 8.9 (+261.8% relative); MGSM 88.4 versus 87. Search cost $8.74 versus ADAS $11.10; inference cost not tabulated. Splits are disjoint, though hand-selecting nine “representative” TravelPlanner queries may bias design.

3. Venue + tier. EMNLP 2025 Main, Poster, verified by the conference presentation page.

21. EvoMAC — Hu et al. (2025)

1. Decision mechanism. For each software requirement, an organizer creates a variable coding-agent DAG. A testing team generates a fixed proxy suite; compiler logs become textual gradients asking whether a subtask is complete, a prompt is erroneous, or a subtask is missing. An update agent removes completed nodes, revises prompts, inserts missing agents, and restructures dependency edges; feed-forward execution, feedback, and “textual backprop” repeat. No weights/RL are trained. This is one of the clearest Q+T topologies, albeit driven by executable feedback.

2. Evaluation. rSDE-Bench has 53 tasks/616 tests: 45 websites (292 basic+247 advanced) and 8 games (46+31); HumanEval 164. Main worker gpt-4o-mini, plus Claude-3.5-Sonnet-20240620. EvoMAC scored website basic/advanced 89.38/65.05, game 77.54/51.60, HumanEval 94.51, versus mini 62.90/44.40/42.76/30.10/88.41 and strong ChatDev 62.67/43.45/53.63/32.26/70.73. Baselines also Gemini, Claude single, MetaGPT, AutoGen, MapCoder and AgentVerse. No token/$ cost. It is training-free; internal generated proxy tests are described as distinct from final tests, reducing conventional leakage, though proxy provenance and test-time compute matter.

3. Venue + tier. ICLR 2025, Poster.

22. AutoAgents — Chen et al. (2024)

1. Decision mechanism. For every query, fixed Planner, Agent Observer and Plan Observer meta-agents spend up to three discussions producing/critiquing a variable specialized team, role prompts, tools, plan steps, assignees and information dependencies. A fixed Action Observer then leads execution, builds step-specific memory, checks status and may replan; self- and collaborative refinement each allow five turns. The objective is qualitative LLM-critic rationality/consensus, with no training or scalar search. Team and plan are Q/T adaptive, but communication remains a hand-coded manager/star with sequential collaboration, not an arbitrary generated graph.

2. Evaluation. GPT-4-0613 only, temperature 0. On all 80 MT-Bench questions, FairEval preferred AutoAgents to single GPT-4 76.3%; three blinded volunteers gave 62.5%. A custom Trivia Creative Writing task used 100 instances each at N=5 and N=10; scores 82.0/85.3 versus Standard 74.6/77.0 and SPP 79.9/84.7. The paper also says “1,000 trivia questions,” inconsistent with 100×5+100×10 occurrences. No token/$ cost, and tools are not enumerated in the main paper. It is zero-training inference, hence no optimize-on-test training, though custom-data construction and a last-20-item ablation are limited.

3. Venue + tier. IJCAI 2024 Main Track; official presentation tier [unverified].

IV. Boundary cases that clarify scope

Three systems are treated as controls rather than members of the dynamic-design corpus. Their role is to calibrate what the dynamic methods are actually being compared against.

23. AgentSquare — Shang et al. (2025)

1. Decision mechanism. This is offline single-agent, not MAS-graph, search. Sixteen source agent designs are decomposed into Planning, Reasoning, Tool Use and Memory module pools, yielding 1,050 combinations in a fixed shell. An LLM alternates FunSearch-like Python module evolution and recombination, while an in-context performance predictor skips unpromising candidates; stop after five stagnant iterations. The task metric selects one fixed architecture per environment.

2. Evaluation. WebShop, ALFWorld, ScienceWorld, M3ToolEval, TravelPlanner and PDDL; gpt-3.5-turbo-0125 and GPT-4o. GPT-4o scores .607/.695/.781/.524/.583/.669 versus strongest search baselines .549/.634/.754/.502/.537/.660; baselines include 12 manual agents, random/Bayesian search, OPRO and ADAS. One SciWorld relative-gain claim conflicts with its table. Dataset subsets and train/validation/test separation are absent; search feedback and reported scores appear to share environments, so optimize-on-reported-set is a concern. Search costs are reported per task ($10.51–$42.14 per GPT-4o iteration) but excluded from downstream comparisons.

3. Venue + tier. ICLR 2025, Poster.

24. MacNet — Qian et al. (2025)

1. Decision mechanism. MacNet is a negative control: the user manually chooses Chain, Star, Tree, Mesh, Layered, or connectivity-preserving Random DAG and size. Every vertex has an actor and every edge a critic/refinement interaction. There is no reward, search, learned router, query conditioning, or topology update. The paper studies scaling and the consequences of topology, not automatic topology decision.

2. Evaluation. MMLU, HumanEval, SRDD and CommonGen-Hard [subset sizes unreported], GPT-3.5 [snapshot unreported], versus CoT, AutoGPT, GPTSwarm and AgentVerse. Random averaged .6522 versus best external AgentVerse .5805 (+7.17 points), but no graph won every domain (for example Chain HumanEval .3720). Random was about 51.92% faster than Mesh at comparable performance; no token/$ headline. Since there is no training, leakage is not applicable, although choosing the best family after inspecting benchmarks is not held-out architecture selection.

3. Venue + tier. ICLR 2025, Poster, verified by the official ICLR program.

25. Optima — Chen et al. (2025)

1. Decision mechanism. Optima keeps a fixed two-agent graph and learns what/when to communicate. Reward is R_task − λ_token R_token + λ_loss/R_loss, where the last term inversely rewards base-LM modeling loss. Initial diverse format prompts generate trajectories; iterative SFT retains high-reward examples. Iterative DPO uses MCTS dialogue trees to construct chosen/rejected trajectories; a hybrid alternates them. Agents may converge/stop early, but roles and edge do not change. It is therefore a useful communication-efficiency boundary, not dynamic topology.

2. Evaluation. Two Llama-3-8B agents (appendix Llama-3.2-3B): split-context information exchange on HotpotQA, 2WikiMultiHopQA, TriviaQA, CBT; solver/critic debate on GSM8K, MATH, ARC-C, MMLU. Baselines CoT, SC(8), multi-agent debate and AutoForm; dataset sizes/splits are not reported. On 2Wiki, iSFT-DPO F1 74.2 with 54.9 tokens versus debate 25.9/543.7; MATH→GSM transfer iDPO 77.9/185.7 versus debate 72.5/514.7. Authors summarize up to 2.8× performance with under 10% of tokens. Missing split provenance prevents a hygiene determination.

3. Venue + tier. Findings of ACL 2025; presentation tier [unverified]. Its separate OpenReview record was only an ICLR submission, not an ICLR acceptance.

Cross-cutting analysis

The closing analysis reads across all 25 entries. It is organized as agreements, disagreements or weak evidence, open problems, and implications for KV-cache-level communication.

What the field agrees on

Dense, uniform communication is usually wasteful. AgentPrune, AgentDropout, G-Designer, AGP, AnyMAC and DySCo all find that substantial edge/context removal can preserve or improve accuracy. This is plausible rather than paradoxical: extra messages consume budget and can amplify correlated errors, sycophancy, or adversarial roles. The repeated empirical result is not that “more agents reason better,” but that selectively exposing complementary evidence is often better than broadcasting everything.

The useful graph is task-dependent. MacNet's six fixed families reverse rank across domains; G-Designer/AGP/ARG-Designer improve by conditioning on the query; CARD additionally conditions on model/tool availability. Query embeddings and role semantics therefore appear more scalable than learning one free adjacency tensor. Yet a graph generator's performance can still reflect benchmark recognition rather than transferable structural reasoning unless evaluated on new domains and roles.

Cost-aware selection matters. MaAS directly penalizes tokens; CARD prices edges; AnyMAC discounts long trajectories and sparsifies context; DySCo scores token cost and exits early. Their gains support joint accuracy–resource optimization. Conversely, an architecture with fewer agents can still be expensive if it calls a stronger model, emits longer reasoning, or serializes steps. Edge count is at best a proxy.

Where evidence disagrees or remains weak

Learned versus hand-designed topology. On matched backbones, query generators often beat complete/fixed graphs and older learned graphs: G-Designer over GPTSwarm, ARG over G-Designer, CARD over its static ablation. Margins are usually modest (roughly 1–3 points in the explicit-graph family), and architecture/data scale grows. MacNet's strong random DAG and PHP's competitiveness with G-Designer show that a careful simple baseline can erase part of the gain. Workflow-code search reports larger improvements because it changes prompts, control flow, verification and tool use simultaneously; those gains cannot be attributed to communication topology alone.

MAS versus one strong model. Several studies compare many calls to GPT-3.5/4o-mini against one call to the same model, not against an equal-dollar stronger model. DyLAN improves on its matched single-agent prompt on MATH, but the gain is only 3.5 points under ComplexCoT (37.6 versus 34.1); CARD's appendix notes simple tasks where a strong single model remains preferable. AFlow's striking DeepSeek/GPT-4 cost comparison is useful, but its searched multi-call workflow should also be compared under equal latency and search-amortization budgets. The defensible claim is Pareto improvement in a specified deployment regime, not universal MAS superiority.

Experimental hygiene. Clean examples include MASS's explicit validation/test sizes, MaAS's custom 1:4 split, and SwarmAgentic's disjoint search/evaluation sets. GPTSwarm's crossword/HumanEval and DyLAN's main selection directly inspect reported data. AnyMAC uses the first 80 test examples when no train set exists. AgentSquare has no disclosed split; FlowReasoner's training/evaluation overlap is unresolved; AGP/ARG/CARD omit essential provenance. Public “test” sets are frequently re-split, and repeated test curves allow informal selection. Architecture research particularly needs a three-way protocol: architecture-search train, architecture-selection validation, and a once-only sealed test—plus a cross-domain test.

Accounting conventions. Papers variously omit the meta-LLM, team-selection trial, graph-generator training, prompt optimizer, failed code executions, or final judge. “Token saving” may mean prompt only, one benchmark, or inference only. Reported dollar costs also age with API prices. A reproducible result should publish input/output tokens by component, peak parallelism, critical-path latency, search cost and expected amortization volume.

Open problems

• True turn-adaptive topology remains rare. DyLAN prunes once; AnyMAC selects a sequential path/context; DySCo rewires heuristically; EvoMAC and FlowReasoner rely on executable feedback. Learned message-conditioned graph policies for open-domain, multi-round work remain largely unexplored.
• Credit assignment and stability. A final-answer reward is noisy for individual edges. Counterfactual edge value, off-policy reuse, causal ablation, and safeguards against routing oscillation or agent starvation are open research problems.
• Generalization across settings. Most controllers are trained separately per benchmark. Needed tests include unseen role pools, unseen agent counts, new LLM families/tools, distribution shift, agent failure and budget changes. CARD and ARG-Designer begin to address conditionality/extensible roles, but evidence is narrow.
• Topology-only ablations. Code-search systems co-optimize prompts, roles, operators and graph. Factorial or constrained ablations are needed to identify whether edges, membership, prompts, verification, or extra sampling caused the gain.
• Decentralization and safety. AgentNet is unusual in routing without a central controller. Decentralized policies raise consistency, deadlock, provenance and access-control questions; a learned edge must not implicitly grant a recipient unauthorized context/tool state.
• Standardized efficiency frontiers. Benchmarks should plot quality against tokens, wall-clock critical path, dollars, energy, memory residency, and failure rate, with equal-budget strong-single-model and random-sparse controls.

Implications for KV-cache-level agent communication

Dynamic topology converts communication optimization into an online cache-routing problem. For an O graph, the serving system can pre-plan prefixes, placement, multicast fan-out and eviction. A Q graph becomes known after a small controller pass, allowing just-in-time placement. A T graph is hardest: AnyMAC may choose an arbitrary subset of old messages, DySCo changes top-k senders, and early exit changes cache lifetime; the future reuse graph is unknown when each KV block is created.

This suggests four concrete research directions. First, represent dialogue state as immutable, content-addressed KV blocks on a message DAG rather than copying concatenated transcripts into every agent cache; an edge then passes references, with copy-on-write private continuations. Second, co-design the topology objective with incremental prefill cost, resident bytes, expected fan-out reuse, transfer distance, eviction/recompute risk and critical-path barriers—not text-token count alone. A sparse graph can have poor locality, while one broadcast prefix may be cheap if its KV is multicast and shared.

Third, treat router uncertainty as a systems signal: keep high-probability parents resident, prefetch only above a calibrated threshold, and compare speculative KV materialization with recomputation. Early-exit confidence should inform cache retention immediately. Fourth, evaluate topology policies and KV schedulers jointly. Useful metrics are cache-hit/reuse ratio, bytes copied between devices, prefill versus decode FLOPs, peak live KV, recomputation, time-to-first/final token, and quality under a fixed memory budget. AnyMAC's learned context gates are the closest current abstraction to KV selection, but all reviewed work communicates text through APIs; none directly optimizes reusable model-layer KV. That gap makes KV-aware graph learning a distinct, well-motivated contribution rather than a mere implementation of existing token sparsity.

References

The numbered list below gives one entry per reviewed paper, with its arXiv link and, where verified, the publication venue.

• Zhuge et al., “Language Agents as Optimizable Graphs” (GPTSwarm), arXiv:2402.16823.
• Zhang et al., “Cut the Crap: An Economical Communication Pipeline for LLM-based Multi-Agent Systems” (AgentPrune), arXiv:2410.02506.
• Wang et al., “AgentDropout,” arXiv:2503.18891.
• Leong and Wu, “DynaSwarm: Dynamically Graph Structure Selection for LLM-based Multi-agent System,” withdrawn arXiv:2507.23261.
• Zhang et al., “G-Designer,” arXiv:2410.11782.
• Li et al., “Adaptive Graph Pruning for Multi-Agent Communication” (AGP), arXiv:2506.02951.
• Li et al., “Assemble Your Crew” (ARG-Designer), arXiv:2507.18224.
• Wu et al., “CARD: Towards Conditional Design of Multi-agent Topological Structures,” arXiv:2603.01089.
• Zhang et al., “Multi-agent Architecture Search via Agentic Supernet” (MaAS), arXiv:2502.04180.
• Liu et al., “A Dynamic LLM-Powered Agent Network for Task-Oriented Agent Collaboration” (DyLAN), arXiv:2310.02170.
• Wang et al., “AnyMAC: Cascading Flexible Multi-Agent Collaboration via Next-Agent Prediction,” arXiv:2506.17784.
• Yang et al., “AgentNet: Decentralized Evolutionary Coordination for LLM-based Multi-Agent Systems,” arXiv:2504.00587.
• Gou and Liu, “Dynamic Trust-Aware Sparse Communication Topology for LLM-Based Multi-Agent Consensus” (DySCo), arXiv:2606.01828.
• Hu, Lu and Clune, “Automated Design of Agentic Systems,” arXiv:2408.08435.
• Zhang et al., “AFlow,” arXiv:2410.10762.
• Wang et al., “ScoreFlow,” arXiv:2502.04306.
• Gao et al., “FlowReasoner,” arXiv:2504.15257.
• Ye et al., “MAS-GPT: Training LLMs to Build LLM-based Multi-Agent Systems,” arXiv:2503.03686.
• “Multi-Agent Design: Optimizing Agents with Better Prompts and Topologies” (MASS), arXiv:2502.02533.
• Zhang et al., “SwarmAgentic,” arXiv:2506.15672.
• Hu et al., “Self-Evolving Multi-Agent Collaboration Networks for Software Development” (EvoMAC), arXiv:2410.16946.
• Chen et al., “AutoAgents,” arXiv:2309.17288.
• Shang et al., “AgentSquare,” arXiv:2410.06153.
• Qian et al., “Scaling Large Language Model-based Multi-Agent Collaboration” (MacNet), arXiv:2406.07155.
• Chen et al., “Optima: Optimizing Effectiveness and Efficiency for LLM-Based Multi-Agent System,” arXiv:2410.08115; Findings of ACL 2025.