AgentsNet: Coordination and Collaborative Reasoning in Multi-Agent LLMs

Bryan Perozzi; Florian Gr\"otschla; Jan T\"onshoff; Luis M\"uller; Mikhail Galkin

REVIEW 3 major objections 5 minor 5 cited by

AgentsNet: Coordination and Collaborative Reasoning in Multi-Agent LLMs

T0 review · 3 major / 5 minor · reviewed 2026-08-06 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read AgentsNet claims to measure multi-agent LLM coordination through five distributed-computing tasks solved under synchronous neighbor-only message-passing, and reports that frontier models coordinate on small graphs but collapse as networks…

desk verdict AgentsNet is a genuinely useful benchmark for multi-agent LLM coordination, but the missing no-communication baseline means the central claim about measuring coordination is not yet established. read the letter →

arxiv 2507.08616 v1 pith:JPOLYQP2 submitted 2025-07-11 cs.MA cs.LG

Florian Grötschla , Luis Müller , Jan Tönshoff , Mikhail Galkin , Bryan Perozzi This is my paper

classification cs.MAcs.LG

keywords multi-agentLLMsystemscoordinationbenchmarkdistributedcomputingLOCALmodelmessagepassinggraphreasoningscalabilityleaderelection

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

AgentsNet is a benchmark that asks networks of LLM-based agents to solve five problems borrowed from distributed computing—graph coloring, minimal vertex cover, maximal matching, leader election, and consensus—using only synchronous message-passing with their immediate neighbors. The paper's central claim is that these tasks measure whether a multi-agent system can genuinely coordinate, self-organize, and communicate under a given network topology, rather than merely answer a reasoning question. On graphs of 4, 8, and 16 nodes, the paper finds that frontier models solve many instances, but performance drops steadily as the network grows, and at 100 agents most tasks are essentially unsolved. The purpose of the benchmark is to create a difficulty scale that can grow with future models, since existing multi-agent benchmarks stop at 2–5 agents. If the claim is right, AgentsNet provides a way to compare agent architectures on their coordination ability, not just their reasoning strength.

What carries the argument

The load-bearing object is the benchmark itself, instantiated as a synchronous message-passing protocol in the style of the LOCAL model: agents sit on the nodes of a graph, exchange text messages only with neighbors in rounds, and finally output a structured answer; the graph families—small-world, scale-free, and geometric (Delaunay) triangulations—and the five tasks fix a difficulty ladder from local coloring to global consensus. The protocol's role is to make the network topology the only channel of information, so that solving a task requires the agents to actually coordinate. Named machinery includes the five problems—$\Delta+1$-coloring, minimal vertex cover, maximal matching, leader election, and consensus—each with a known distributed round complexity, and the binary 'fully solved' scoring rule that requires the whole network's output to be correct.

What would settle it

Run a no-communication baseline on the same 27 graph instances: each agent is shown its own system prompt and final-response query but receives no messages from neighbors, and scores are computed exactly as in the paper. If that baseline matches or exceeds the message-passing scores on any of the five tasks, the benchmark's claim that it measures coordination rather than individual reasoning would be contradicted.

Watch

Extended reading notes

Core claim

The paper's central discovery is a measurement protocol: by grounding agentic tasks in the LOCAL model of distributed computing, the performance of an LLM agent network on these five problems becomes a proxy for its capacity to coordinate. Each agent is a separate LLM instance with a system prompt describing the task, a list of neighbors, and a fixed number of synchronous rounds; agents exchange JSON messages only with neighbors and must give a final parseable answer. The benchmark counts an instance as solved only when the entire network's answers satisfy the task's global constraints, e.g., exactly one leader or a proper coloring. Under this protocol, the strongest tested models reach aggregate scores around 0.70–0.80 on small graphs, while a mid-tier model falls from roughly 85 percent solved consensus instances at 20 agents to 15 percent at 100 agents and near zero for most other tasks. The authors read this as evidence that frontier LLMs can coordinate on small networks but lose coherent global strategy as network size and communication history grow.

Load-bearing premise

The load-bearing premise is construct validity: solving these five distributed-computing puzzles under the fixed synchronous message-passing protocol is treated as a genuine measure of multi-agent coordination, even though the paper reports no single-agent or no-communication baseline to separate coordination from individual reasoning.

Editorial extensions

If this is right

If AgentsNet measures coordination as claimed, then increasing the number of agents is a tunable difficulty knob: the benchmark can be made harder without redesign, simply by sampling larger graphs.
Models already differ sharply on the benchmark (e.g., aggregate scores from 0.26 to 0.80), so the protocol can discriminate between architectures on coordination ability, not just reasoning.
The scaling study implies that current frontier LLMs are not yet able to maintain coherent global strategies beyond roughly 20–30 agents, so the practical ceiling on decentralized LLM agent networks is near that size.
Because the tasks have known distributed lower bounds, benchmark performance can be compared against what a correct distributed algorithm would need, giving a principled floor for what coordination ought to require.
The failures documented in transcripts—late strategy agreement, uncritical acceptance of neighbor messages, and reliance on outdated information—point to concrete mechanisms that limit coordination and could be targeted by future training or prompting.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

Inference: the same protocol could be run with heterogeneous agents (different models, different prompts) or with faulty or adversarial agents, which the paper explicitly leaves out; those settings might change scores substantially and would test robustness rather than cooperative ability.
Inference: because the paper lacks a no-communication or single-agent baseline, part of the observed performance on small graphs may reflect individual reasoning rather than emergent coordination; a direct comparison would separate the two.
Inference: the qualitative finding that agents uncritically accept neighbor messages suggests a testable extension—measuring how often a deliberately corrupted message propagates through the network—which would quantify trust dynamics in LLM agent systems.
Inference: the soft scores in the appendix show partial progress even when strict solve rates are low, so a continuous metric might be more sensitive for comparing models near the scaling cliff; the paper itself notes this tension.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

AgentsNet is worth a look. It fills a real gap: existing multi-agent LLM benchmarks top out at a handful of agents and mostly use open-ended tasks, while this one scales to 100 agents and evaluates on five classic distributed computing problems with formal correctness criteria. The protocol is clearly specified, the graph generators are standard, the authors report standard errors, and they ship code and data. The qualitative analysis is also a genuine strength—the transcripts show real coordination behaviors like agents correcting each other's color assignments and adapting to stale information.

The main soft spot is the missing no-communication baseline. The abstract and Section 3.1 claim AgentsNet measures collaborative strategy formation, self-organization, and coordination. But without a T=0 condition or a single-agent control, the aggregate solve rates could largely reflect per-agent priors rather than anything the network does. The Consensus numbers are the clearest warning: several models hit 0.99–1.00, which is exactly what you would expect if every agent just outputs 0. Coloring and Vertex Cover can also be partially solved by simple heuristics like picking a degree-based response. This is not a minor omission—it directly blocks the interpretative claim that the benchmark isolates coordination from individual reasoning. The Limitations sections (Section 6 and Appendix G) list several valid caveats but do not mention this missing control, which should have been the first thing on the list.

Two smaller issues. The 100-agent scaling result rests on a single model (Gemini 2.0 Flash), so the claim that performance degrades with network size is supported for that model but not as a general statement. And the abstract's "practically unlimited" phrasing is too strong given that current models collapse at 100 agents and the cost grows quickly; "scalable in principle" would be accurate.

None of this sinks the paper. The benchmark itself is well designed, the tasks are appropriate, and the missing baseline is easily added in a revision. The paper demonstrates clear thinking and honest engagement with the literature. I would send this to peer review, with a strong request for the baseline as a condition of acceptance. Readers interested in multi-agent evaluation or LLM coordination will get value from the task suite even if they do not yet accept the construct-validity claim.

Referee Report

3 major / 5 minor

Summary. The paper introduces AgentsNet, a benchmark for multi-agent LLM coordination built from five distributed-computing problems: (Delta+1)-Coloring, Minimal Vertex Cover, Maximal Matching, Leader Election, and Consensus. Agents communicate only with graph neighbors through synchronous message-passing rounds, and the benchmark reports both strict solved-instance fractions and soft scores. The authors evaluate ten frontier and open-weight LLMs on graphs of 4, 8, and 16 nodes, and add a scaling study up to 100 agents using one model. They report that performance degrades as network size grows, with strong small-network results for several frontier models, and they provide qualitative transcript analyses of coordination successes and failures.

Significance. If its construct validity can be established, AgentsNet is a valuable complement to existing multi-agent benchmarks: the tasks have formal correctness criteria, the evaluation does not fit model outputs to the data, and the benchmark is open-source and scalable in principle. The qualitative transcript analysis is a genuine strength, as it documents concrete coordination behaviors such as self-initiated conflict resolution and strategy propagation. However, the central interpretative claim that the benchmark measures coordination and collaboration rather than individual response biases is not yet supported by the experiments, so the significance of the contribution is currently conditional on additional controls.

major comments (3)

[Section 5.2, Table 2 and Section 3.1] The headline claim that AgentsNet measures the ability of multi-agent systems to collaboratively form strategies, self-organize, and communicate (Abstract; Section 3.1) is not yet established because the paper reports no no-communication or single-agent baseline. On Consensus, an agent that receives no neighbor messages can simply answer '0', and if all agents share the same LLM prior, the network can solve the task without any coordination; the near-perfect Consensus fractions in Table 2 (e.g., Claude 3.7 Sonnet 1.00, Gemini 2.5 Flash 1.00) are compatible with this alternative explanation. Similarly, Coloring and Vertex Cover can be partially addressed by degree- or name-based heuristics. I ask the authors to add a T=0 no-message condition using the same prompts, graphs, and final-response protocol, and to report solved fractions per task per model against that control. Without this comparison, the quantitative results cannot be attributed to the message-passing protocol rather than to individual response biases or prompt following.
[Section 5.3, Figure 5] The scaling experiment rests on a single model (Gemini 2.0 Flash) and reports average solved fractions without standard errors, repeat counts, or per-instance variance. The statement that 'performance smoothly decreases as the network grows' and that difficulty can be gradually increased is therefore only weakly supported. The authors should either add at least one additional model and repeated runs with error bars, or explicitly frame Figure 5 as an exploratory single-model observation rather than a benchmark property.
[Section 6 and Appendix G] The limitations sections list synchronous communication, JSON parsing, and homogeneous agents, but do not acknowledge the missing no-communication baseline, which is the main threat to the paper's central claim. This should be discussed explicitly, and the proposed control should be listed as necessary future work if it is not added in the revision.

minor comments (5)

[Figure 5] The axis label 'T ask' contains a typo and should read 'Task'.
[Appendix B, Table 4] The soft-score discussion notes that random baselines can already exceed 50% for Coloring, but the paper does not provide random or trivial baselines for the binary solved-fraction scores in Table 2; adding such baselines would help interpret the absolute numbers.
[Section 5.1 and Appendix C] The text says 'we run at least one repeat per graph' and Appendix C defines a general formula with ni runs, but the number of repeats actually used is not reported anywhere; please state the exact number of runs per graph instance and configuration for reproducibility.
[Section 3.1 and Appendix B] For Consensus, the task has no initial input values, so any fixed output is a valid solution; the paper should clarify that this variant tests agreement only and discuss how this choice affects the interpretation of high Consensus scores.
[Figure 4] Figure 4 is visually dense because of the many small numeric labels and color categories; consider simplifying it or moving the per-size breakdown entirely to a table, as the main text already references Table 2.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: AgentsNet's tasks, graph generators, and scoring criteria are fixed before evaluation, and reported scores are direct formal checks rather than fitted or self-citation-derived predictions.

full rationale

AgentsNet is a benchmark rather than a predictive or fitted model, so the main circularity patterns do not apply. The five tasks ((Delta+1)-Coloring, Minimal Vertex Cover, Maximal Matching, Leader Election, Consensus) are defined in Section 3.1 with fixed formal solution criteria, and Section 4 fixes the message-passing protocol and final-response format before any model is run. Scores are computed by checking final answers against these criteria exactly (e.g., exactly one 'Yes' for LEADER ELECTION, all agents announcing the same value for CONSENSUS), with no parameter fitted to model outputs and no quantity predicted from a fitted input. The claim that the benchmark 'measures the ability' of multi-agent systems is an interpretive construct-validity claim, not a derivation that reduces to its inputs. The paper itself notes in Appendix B that even a naive random baseline can score well on soft scores, and therefore emphasizes the binary solved-instance metric; this shows awareness of baselines rather than circularity. The only apparent self-citations are related-work references such as Fatemi et al. [15] and Sanford et al. [40], which are used to position graph-reasoning research and are not load-bearing for AgentsNet's central claims. The skeptical concern about a missing no-communication or single-agent baseline is a real validity limitation, but it is a question of whether the scores measure coordination versus individual priors; it is not evidence that any score is equivalent to an input by construction. No uniqueness theorem is imported from the authors' prior work, no ansatz is smuggled in via citation, and no known result is merely renamed. Overall, the derivation chain is self-contained with respect to the benchmark's evaluation logic, so the circularity score is 0.

Assumptions & free parameters 1 free parameters · 6 assumptions · 0 invented entities

The benchmark rests on standard graph theory facts (existence of colorings, vertex covers, matchings, and consensus/leader election solvability) and on the domain assumption that performance on these tasks reflects coordination ability. No fitted parameters or invented entities are introduced; the only hand-chosen quantity is the number of message-passing rounds for local tasks.

free parameters (1)

Message-passing rounds for local tasks = 4 (4 nodes), 5 (8 nodes), 6 (16 nodes)
Chosen by hand based on graph size; the paper does not justify why these suffice for local distributed algorithms, and insufficient rounds could understate model coordination ability on larger graphs.

assumptions (6)

standard math (Δ+1)-coloring exists for every graph, so the coloring task always has a valid solution.
Invoked in Section 3.1 when defining the COLORING task with Δ+1 groups; guarantees the task is feasible.
standard math Every graph has an inclusion-minimal vertex cover and a maximal matching.
Invoked in Section 3.1 for VERTEX COVER and MATCHING; ensures valid solutions exist.
standard math Consensus and leader election are solvable in connected synchronous networks given enough rounds (O(D)).
Section 3.1 and Table 1; the paper sets 2D+1 rounds to ensure global information propagation.
domain assumption Success on these five tasks is a valid indicator of multi-agent LLM coordination and collaboration ability.
Core construct validity assumption stated in the abstract and Section 1; if false, the benchmark measures individual reasoning or prompt compliance instead.
domain assumption Stochastic LLM agent behavior aligns with the randomized LOCAL model of distributed computing.
Section 4; justifies using synchronous message-passing with neighbor-only communication as the protocol.
domain assumption Watts-Strogatz, Barabasi-Albert, and Delaunay graphs represent relevant multi-agent communication topologies.
Section 3.2; the benchmark's conclusions about coordination are claimed to generalize to real-world network structures.

how reviews work

0 comments

Cite this review

Pith. "Pith review of AgentsNet: Coordination and Collaborative Reasoning in Multi-Agent LLMs." pith.science (2026). https://pith.science/paper/JPOLYQP2

@misc{pith2026250708616,
  author       = {Pith},
  title        = {Pith review of: AgentsNet: Coordination and Collaborative Reasoning in Multi-Agent LLMs},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/JPOLYQP2}},
  note         = {Machine review of arXiv:2507.08616}
}

read the original abstract

Large-language models (LLMs) have demonstrated powerful problem-solving capabilities, in particular when organized in multi-agent systems. However, the advent of such systems also raises several questions on the ability of a complex network of agents to effectively self-organize and collaborate. While measuring performance on standard reasoning benchmarks indicates how well multi-agent systems can solve reasoning tasks, it is unclear whether these systems are able to leverage their topology effectively. Here, we propose AgentsNet, a new benchmark for multi-agent reasoning. By drawing inspiration from classical problems in distributed systems and graph theory, AgentsNet measures the ability of multi-agent systems to collaboratively form strategies for problem-solving, self-organization, and effective communication given a network topology. We evaluate a variety of baseline methods on AgentsNet including homogeneous networks of agents which first have to agree on basic protocols for organization and communication. We find that some frontier LLMs are already demonstrating strong performance for small networks but begin to fall off once the size of the network scales. While existing multi-agent benchmarks cover at most 2-5 agents, AgentsNet is practically unlimited in size and can scale with new generations of LLMs. As such, we also probe frontier models in a setup with up to 100 agents.

Figures

Figures reproduced from arXiv: 2507.08616 by the authors.

**Figure 1.** Mean AGENTSNET score of models versus API costs per repeat (May 15, 2025). Error bars indicate standard error of the mean. Gold stars denote Paretooptimal models. AGENTSNET assesses the agent’s coordinative and collaborative capabilities through fundamental problems in distributed computing. Concretely, we identify five central problems from the distributed systems literature to construct corresponding coordina… view at source ↗

**Figure 2.** Example communication between three agents on a simplified topology. Agents Emily, [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗

**Figure 3.** Overview of the tasks in AGENTSNET: In LEADERELECTION, the task is to select a single agent as the leader of the network. In CONSENSUS, the task is for all agents to agree on a specific value, for example 0 or 1. In MATCHING, the task is for pairs of agents to team up without conflicts. In COLORING, the task is for agents to select a group (indicated by a color), such that none of their neighbors are in the same gro… view at source ↗

Figures from the paper (5 more)

**Figure 4.** Figure 4: Fraction of solved instances per task and model, grouped by graph size (4, 8, and 16 nodes). [PITH_FULL_IMAGE:figures/full_fig_p008_4.png]

**Figure 5.** Figure 5: Scalability of Gemini 2.0 Flash on AGENTSNET: Average fraction of successfully solved instances per task as the graph size increases from 20 to 100 agents. In addition to our main results, we provide additional results for networks of up to 100 agents in [PITH_FULL_I…

**Figure 6.** Figure 6: Network topologies of AGENTSNET generated from SMALLWORLD graphs. benchmarking coordination strategies. Notably, Kearns et al. [22] also draws a comparison between the two and claims that graphs generated with a preferential attachment model were more difficult to solv…

**Figure 7.** Figure 7: Network topologies of AGENTSNET generated from SCALEFREE graphs. E Extended Qualitative Analysis E.1 K4 or Star? Next, we present an illustrative example for a failure case arising from our key findings. Here, the task is VERTEXCOVER on a complete graph with 4 nodes an…

**Figure 8.** Figure 8: Network topologies of AGENTSNET generated from DELAUNAY graphs. Douglas Jeremy’s last message defines the graph as a star centered at Jeremy [...] If we choose only Jeremy as the sole coordinator, all edges are covered [...] Only Danielle recognizes Jeremy’s suggested …

Discussion (0). Sign in to comment.

Forward citations

Cited by 5 Pith papers

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

An Empirical Study of Coordination Mode as the First-Class Citizen in From-Scratch Multi-Agent Coding
cs.AI 2026-07 conditional novelty 6.0 of 10

A new multi-agent coding benchmark (MSEval) shows that collaboration topology—not just model ability—strongly shifts the speed, cost, and quality of LLM-built software.
Toward an Organizational Science of Multi-Agent LLM Systems: Decoupling Who, How, and Which Algorithm
cs.AI 2026-07 conditional novelty 6.0 of 10

A framework that decouples team composition, coordination, and fusion algorithm in multi-agent LLM systems, plus an adaptive router that learns per-task protocol choices.
Social Networks of LLM Agents
cs.LG 2026-07 conditional novelty 6.0 of 10

Attention width and source social power determine whether LLM agent networks herd or achieve wisdom-of-crowds, with a pricing equalizer restoring optimal collective weights.
Collective Cognition in Hybrid Groups: A Network Science Synthesis
cs.HC 2026-07 conditional novelty 5.0 of 10

Hybrid human–AI groups are the heterogeneous case of collective intelligence, and network effects from human-only or AI-only systems must be revised for mixed nodes, mixed links, and interface roles.
Cost and Accuracy of Long-Term Memory in Distributed Multi-Agent Systems Based on Large Language Models
cs.IR 2026-01 reject novelty 5.0 of 10

A two-framework testbed comparison claims mem0 is Pareto-optimal over Graphiti for distributed LLM agents because its lower cost is paired with accuracy that is not significantly different.

Reference graph

Works this paper leans on

59 extracted references · 49 canonical work pages · cited by 5 Pith papers

[1]

Agashe, S., Fan, Y ., Reyna, A., and Wang, X. E. (2024). Llm-coordination: evaluating and analyz- ing multi-agent coordination abilities in large language models. arXiv preprint arXiv:2310.03903

arXiv 2024
[2]

Angluin, D. (1980). Local and global properties in networks of processors. In Proceedings of the twelfth annual ACM symposium on Theory of computing, pages 82–93

work page 1980
[3]

The claude 3 model family: Opus, sonnet, haiku

Anthropic (2024). The claude 3 model family: Opus, sonnet, haiku

work page 2024
[4]

and Albert, R

Barabási, A.-L. and Albert, R. (1999). Emergence of scaling in random networks. science, 286(5439):509–512

work page 1999
[5]

Barenboim, L. (2016). Deterministic ( δ+ 1)-coloring in sublinear (in δ) time in static, dynamic, and faulty networks. Journal of the ACM (JACM), 63(5):1–22

work page 2016
[6]

Chase, H. (2022). LangChain

work page 2022
[7]

Chen, H., Ji, W., Xu, L., and Zhao, S. (2023). Multi-agent consensus seeking via large language models. arXiv preprint arXiv:2310.20151

arXiv 2023
[8]

Chen, M., Tworek, J., Jun, H., Yuan, Q., de Oliveira Pinto, H. P., Kaplan, J., Edwards, H., Burda, Y ., Joseph, N., Brockman, G., Ray, A., Puri, R., Krueger, G., Petrov, M., Khlaaf, H., Sastry, G., Mishkin, P., Chan, B., Gray, S., Ryder, N., Pavlov, M., Power, A., Kaiser, L., Bavarian, M., Winter, C., Tillet, P., Such, F. P., Cummings, D., Plappert, M., C...

work page 2021

Show all 59 references

[9]

Chen, W., Su, Y ., Zuo, J., Yang, C., Yuan, C., Chan, C.-M., Yu, H., Lu, Y ., Hung, Y .-H., Qian, C., Qin, Y ., Cong, X., Xie, R., Liu, Z., Sun, M., and Zhou, J. (2024a). Agentverse: Facilitating multi- agent collaboration and exploring emergent behaviors. In The Twelfth Inter...

2024
[10]

Chen, W., You, Z., Li, R., Guan, Y ., Qian, C., Zhao, C., Yang, C., Xie, R., Liu, Z., and Sun, M. (2024b). Internet of agents: Weaving a web of heterogeneous agents for collaborative intelligence. arXiv preprint arXiv:2407.07061

2024 arXiv
[11]

Chiang, Y .-S., Cho, H.-C., and Chang, C.-J. (2024). Adaptive networks driven by partner choice can facilitate coordination among humans in the graph coloring game: Evidence from a network experiment. Collective Intelligence, 3(3):26339137241285901

2024
[12]

Chuang, Y .-S., Goyal, A., Harlalka, N., Suresh, S., Hawkins, R., Yang, S., Shah, D., Hu, J., and Rogers, T. (2024). Simulating opinion dynamics with networks of LLM-based agents. In Findings of the Association for Computational Linguistics: NAACL 2024

2024
[13]

B., and Mordatch, I

Du, Y ., Li, S., Torralba, A., Tenenbaum, J. B., and Mordatch, I. (2023). Improving factuality and reasoning in language models through multiagent debate. In Forty-first International Conference on Machine Learning

2023
[14]

Erdos, P., Rényi, A., et al. (1960). On the evolution of random graphs. Publ. math. inst. hung. acad. sci, 5(1):17–60

1960
[15]

Fatemi, B., Halcrow, J., and Perozzi, B. (2024). Talk like a graph: Encoding graphs for large language models. In International Conference on Learning Representations (ICLR). 10

2024
[16]

J., Lynch, N

Fischer, M. J., Lynch, N. A., and Paterson, M. S. (1985). Impossibility of distributed consensus with one faulty process. Journal of the ACM (JACM), 32(2):374–382

1985
[17]

Gemini 2.0: A new ai model for the agentic era

Google (2024). Gemini 2.0: A new ai model for the agentic era

2024
[18]

Developers can now start building with gemini 2.5 flash

Google (2025a). Developers can now start building with gemini 2.5 flash

2025
[19]

Gemini 2.5: Our newest gemini model with thinking

Google (2025b). Gemini 2.5: Our newest gemini model with thinking

2025
[20]

Hendrycks, D., Burns, C., Basart, S., Zou, A., Mazeika, M., Song, D., and Steinhardt, J. (2021). Measuring massive multitask language understanding. Proceedings of the International Conference on Learning Representations (ICLR)

2021
[21]

Judd, S., Kearns, M., and V orobeychik, Y . (2010). Behavioral dynamics and influence in net- worked coloring and consensus. Proceedings of the National Academy of Sciences, 107(34):14978– 14982

2010
[22]

Kearns, M., Suri, S., and Montfort, N. (2006). An experimental study of the coloring problem on human subject networks. science, 313(5788):824–827

2006
[23]

and Wattenhofer, R

Lenzen, C. and Wattenhofer, R. (2012). Distributed algorithms for sensor networks. Philo- sophical Transactions of the Royal Society A: Mathematical, Physical and Engineering Sciences, 370(1958):11–26

2012
[24]

Liang, T., He, Z., Jiao, W., Wang, X., Wang, Y ., Wang, R., Yang, Y ., Shi, S., and Tu, Z. (2024). Encouraging divergent thinking in large language models through multi-agent debate. In Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing, pag...

2024
[25]

Linial, N. (1992). Locality in distributed graph algorithms. SIAM Journal on computing , 21(1):193–201

1992
[26]

Liu, X., Yu, H., Zhang, H., Xu, Y ., Lei, X., Lai, H., Gu, Y ., Ding, H., Men, K., Yang, K., Zhang, S., Deng, X., Zeng, A., Du, Z., Zhang, C., Shen, S., Zhang, T., Su, Y ., Sun, H., Huang, M., Dong, Y ., and Tang, J. (2024). Agentbench: Evaluating LLMs as agents. InThe Twelfth...

2024
[27]

Liu, Z., Zhang, Y ., Li, P., Liu, Y ., and Yang, D. (2023). Dynamic llm-agent network: An llm- agent collaboration framework with agent team optimization. arXiv preprint arXiv:2310.02170

2023 arXiv
[28]

Lynch, N. A. (1996). Distributed algorithms. Elsevier

1996
[29]

Marro, S., La Malfa, E., Wright, J., Li, G., Shadbolt, N., Wooldridge, M., and Torr, P. (2024). A scalable communication protocol for networks of large language models. arXiv preprint arXiv:2410.11905

2024 arXiv
[30]

The llama 4 herd: The beginning of a new era of natively multimodal ai innovation

Meta (2025). The llama 4 herd: The beginning of a new era of natively multimodal ai innovation

2025
[31]

Mialon, G., Fourrier, C., Wolf, T., LeCun, Y ., and Scialom, T. (2024). GAIA: a benchmark for general AI assistants. In The Twelfth International Conference on Learning Representations

2024
[32]

Miller, E. (2024). Adding error bars to evals: A statistical approach to language model evaluations. arXiv preprint arXiv:2411.00640

2024 arXiv
[33]

Ni, A., Desai, R., Li, Y ., Lei, X., Wang, D., Raghavendra, R., Ghosh, G., Li, D., and Celikyilmaz, A. (2025). Collaborative reasoner: Self-improving social agents with synthetic conversations. arXiv preprint

2025
[34]

Introducing gpt-4.1 in the api

OpenAI (2025a). Introducing gpt-4.1 in the api

2025
[35]

Introducing openai o3 and o4-mini

OpenAI (2025b). Introducing openai o3 and o4-mini

2025
[36]

S., O’Brien, J., Cai, C

Park, J. S., O’Brien, J., Cai, C. J., Morris, M. R., Liang, P., and Bernstein, M. S. (2023). Generative agents: Interactive simulacra of human behavior. In Proceedings of the 36th annual acm symposium on user interface software and technology, pages 1–22. 11

2023
[37]

Peleg, D. (2000). Distributed computing: a locality-sensitive approach. SIAM

2000
[38]

Qian, C., Xie, Z., Wang, Y ., Liu, W., Dang, Y ., Du, Z., Chen, W., Yang, C., Liu, Z., and Sun, M. (2024). Scaling large-language-model-based multi-agent collaboration. arXiv preprint arXiv:2406.07155

2024 arXiv
[39]

Regan, C., Gournail, A., and Oka, M. (2024). Problem-solving in language model networks. In Artificial Life Conference Proceedings 36

2024
[40]

Sanford, C., Fatemi, B., Hall, E., Tsitsulin, A., Kazemi, M., Halcrow, J., Perozzi, B., and Mirrokni, V . (2024). Understanding transformer reasoning capabilities via graph algorithms. In The Thirty-eighth Annual Conference on Neural Information Processing Systems

2024
[41]

Schaeffer, R., Miranda, B., and Koyejo, S. (2023). Are emergent abilities of large language models a mirage? In NeurIPS

2023
[42]

Skianis, K., Nikolentzos, G., and Vazirgiannis, M. (2024). Graph reasoning with large language models via pseudo-code prompting

2024
[43]

Tang, J., Zhang, Q., Li, Y ., Chen, N., and Li, J. (2025). Evaluating and improving large language models on graph computation. In The Thirteenth International Conference on Learning Representations

2025
[44]

Wang, H., Feng, S., He, T., Tan, Z., Han, X., and Tsvetkov, Y . (2024). Can language models solve graph problems in natural language? Advances in Neural Information Processing Systems, 36

2024
[45]

Watts, D. J. and Strogatz, S. H. (1998). Collective dynamics of ‘small-world’networks. nature, 393(6684):440–442

1998
[46]

Xiong, K., Ding, X., Cao, Y ., Liu, T., and Qin, B. (2023). Examining inter-consistency of large language models collaboration: An in-depth analysis via debate. In The 2023 Conference on Empirical Methods in Natural Language Processing

2023
[47]

K., and Feng, J

Xu, L., Hu, Z., Zhou, D., Ren, H., Dong, Z., Keutzer, K., Ng, S. K., and Feng, J. (2023). Magic: Benchmarking large language model powered multi-agent in cognition, adaptability, rationality and collaboration. arXiv preprint arXiv:2311.08562

2023 arXiv
[48]

Yang, Z., Zhang, Z., Zheng, Z., Jiang, Y ., Gan, Z., Wang, Z., Ling, Z., Chen, J., Ma, M., Dong, B., Gupta, P., Hu, S., Yin, Z., Li, G., Jia, X., Wang, L., Ghanem, B., Lu, H., Lu, C., Ouyang, W., Qiao, Y ., Torr, P., and Shao, J. (2024). Oasis: Open agent social interaction si...

2024
[49]

Yao, S., Shinn, N., Razavi, P., and Narasimhan, K. (2024). Tau-bench: A benchmark for tool-agent-user interaction in real-world domains. arXiv preprint arXiv:2406.12045

2024 arXiv
[50]

Yin, G., Bai, H., Ma, S., Nan, F., Sun, Y ., Xu, Z., Ma, S., Lu, J., Kong, X., Zhang, A., et al. (2024). Mmau: A holistic benchmark of agent capabilities across diverse domains. arXiv preprint arXiv:2407.18961

2024 arXiv
[51]

Zhang, Z., Wang, X., Zhang, Z., Li, H., Qin, Y ., and Zhu, W. (2024). Llm4dyg: Can large language models solve spatial-temporal problems on dynamic graphs? In Proceedings of the 30th ACM SIGKDD Conference on Knowledge Discovery and Data Mining, KDD ’24, page 4350–4361, New Yor...

2024
[52]

R., Csordás, R., Gopalakrishnan, A., Hamdi, A., Hammoud, H

Zhuge, M., Liu, H., Faccio, F., Ashley, D. R., Csordás, R., Gopalakrishnan, A., Hamdi, A., Hammoud, H. A. A. K., Herrmann, V ., Irie, K., Kirsch, L., Li, B., Li, G., Liu, S., Mai, J., Piekos, P., Ramesh, A. A., Schlag, I., Shi, W., Stanic, A., Wang, W., Wang, Y ., Xu, M., Fan,...

2023
[53]

Zhuge, M., Wang, W., Kirsch, L., Faccio, F., Khizbullin, D., and Schmidhuber, J. (2024). Gptswarm: Language agents as optimizable graphs. In ICML. 12 A Implementation Details Here, we describe implementation details of AGENTS NET. Message-Passing. Algorithm 1 gives an overview...

2024
[54]

Everybody has a unique name

There are [n] agents in total. Everybody has a unique name. Your name is [name]
[55]

You cannot see or directly communicate with anyone else, unless information is relayed by intermediate agents

You can only communicate with your immediate neighbors ([neighbors]). You cannot see or directly communicate with anyone else, unless information is relayed by intermediate agents
[56]

In each round, you will first receive the last messages sent by your neighbors and then be asked to generate your response messages which your neighbors receive in the next round

You can exchange text-based messages with your neighbors in rounds. In each round, you will first receive the last messages sent by your neighbors and then be asked to generate your response messages which your neighbors receive in the next round. This process repeats for [r] ...
[57]

In every round, think step-by-step about the next set of messages you want to send

Everybody (including you) decides what to share or request from neighbors. In every round, think step-by-step about the next set of messages you want to send. Output a JSON string that contains your response messages
[58]

Alan": "Message that will be sent to Alan

The messages you send to your neighbors are formatted as JSON. For example, if your neighbors are Alan and Bob, your output should look as follows: ‘‘‘ {"Alan": "Message that will be sent to Alan.", "Bob": "Message that will be sent to Bob."} ‘‘‘ It is not mandatory to send a ...
[59]

priority

After [r] message passes, you have to solve the following task: [task2]. B Benchmark Tasks Here, we describe the tasks in AGENTS NET in detail. (∆ + 1)-Coloring. Each node is assigned a color using at most ∆ + 1 colors, where ∆ is the maximum node degree. This problem has a we...

Pith tools

Reviewed August 6, 2026 · model on record in the stance chip above.

[1] [1]

Agashe, S., Fan, Y ., Reyna, A., and Wang, X. E. (2024). Llm-coordination: evaluating and analyz- ing multi-agent coordination abilities in large language models. arXiv preprint arXiv:2310.03903

arXiv 2024

[2] [2]

Angluin, D. (1980). Local and global properties in networks of processors. In Proceedings of the twelfth annual ACM symposium on Theory of computing, pages 82–93

work page 1980

[3] [3]

The claude 3 model family: Opus, sonnet, haiku

Anthropic (2024). The claude 3 model family: Opus, sonnet, haiku

work page 2024

[4] [4]

and Albert, R

Barabási, A.-L. and Albert, R. (1999). Emergence of scaling in random networks. science, 286(5439):509–512

work page 1999

[5] [5]

Barenboim, L. (2016). Deterministic ( δ+ 1)-coloring in sublinear (in δ) time in static, dynamic, and faulty networks. Journal of the ACM (JACM), 63(5):1–22

work page 2016

[6] [6]

Chase, H. (2022). LangChain

work page 2022

[7] [7]

Chen, H., Ji, W., Xu, L., and Zhao, S. (2023). Multi-agent consensus seeking via large language models. arXiv preprint arXiv:2310.20151

arXiv 2023

[8] [8]

Chen, M., Tworek, J., Jun, H., Yuan, Q., de Oliveira Pinto, H. P., Kaplan, J., Edwards, H., Burda, Y ., Joseph, N., Brockman, G., Ray, A., Puri, R., Krueger, G., Petrov, M., Khlaaf, H., Sastry, G., Mishkin, P., Chan, B., Gray, S., Ryder, N., Pavlov, M., Power, A., Kaiser, L., Bavarian, M., Winter, C., Tillet, P., Such, F. P., Cummings, D., Plappert, M., C...

work page 2021