A practical guide to building agents

Explains when agents are appropriate, how to define their tools and instructions, and how to move from one agent to manager and handoff-based multi-agent patterns.

A useful first check on whether distinct roles justify the coordination cost of a graph.


Building effective agents

Distinguishes workflows from autonomous agents and presents routing, parallelization, orchestrator-worker, and evaluator-optimizer patterns.

Provides a compact topology vocabulary and a strong case for adding coordination only when the task demands it.


Agent-Oriented Programming

Defines a programming paradigm in which agents are first-class components described through mental state and governed by explicit interaction rules.

Establishes the intellectual lineage for treating an agent role as a programmable organizational unit.


Intelligent Agents: Theory and Practice

Michael Wooldridge; Nicholas R. Jennings

Surveys the properties, architectures, and engineering approaches that distinguish autonomous agents from ordinary software modules.

Grounds the agency-at-the-nodes boundary that separates an agent graph from a deterministic workflow.


The Blackboard Model of Problem Solving and the Evolution of Blackboard Architectures

Describes systems in which independent specialists coordinate opportunistically through a shared problem state and a control component.

Supplies a durable model for shared state without requiring every node to exchange its full context directly.


Learning to Communicate with Deep Multi-Agent Reinforcement Learning

Jakob Foerster; Ioannis Alexandros Assael; Nando de Freitas; Shimon Whiteson

Introduces reinforcement-learning methods that let agents learn communication protocols alongside their task policies, including discrete messages for execution.

Shows that edge content and communication policy can be engineered or learned rather than treated as free-form chat.


TarMAC: Targeted Multi-Agent Communication

Uses attention to let agents address different messages to selected recipients instead of broadcasting the same information to the whole team.

Motivates selective, recipient-aware handoffs when all-to-all communication is wasteful or distracting.


AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversations

Qingyun Wu; Gagan Bansal; Jieyu Zhang; Yiran Wu; Beibin Li; Erkang Zhu; Li Jiang; Xiaoyun Zhang; Shaokun Zhang; Jiale Liu; Ahmed Hassan Awadallah; Ryen W. White; Doug Burger; Chi Wang

Presents a framework for composing customizable conversational agents that can combine language models, tools, code execution, and human input.

An early, influential demonstration that agent roles and conversation links can be expressed as an executable topology.


GPTSwarm: Language Agents as Optimizable Graphs

Represents language-agent systems as computational graphs and optimizes graph components from task feedback.

Makes the graph itself an optimization target rather than a fixed orchestration diagram.


A Dynamic LLM-Powered Agent Network for Task-Oriented Agent Collaboration

Constructs task-specific collaboration networks that can vary which agents participate and how they communicate instead of relying on one fixed team.

Provides evidence for adapting the work graph to the task while keeping the available agent roles reusable.


Cut the Crap: An Economical Communication Pipeline for LLM-based Multi-Agent Systems

Studies an economical communication pipeline that reduces redundant information exchanged among language-model agents.

Treats edge traffic as a measurable cost and tests whether less communication can preserve useful collaboration.


G-Designer: Architecting Multi-agent Communication Topologies via Graph Neural Networks

Uses graph neural networks to design communication structures for multi-agent systems instead of assuming a complete or manually chosen graph.

Connects task performance to explicit topology search and exposes communication structure as an engineering variable.


Automated Design of Agentic Systems

Uses a meta-agent to propose, evaluate, and iteratively improve code-defined agentic systems across tasks.

Demonstrates automated search over coordination logic while retaining executable artifacts that engineers can inspect.


AFlow: Automating Agentic Workflow Generation

Searches over reusable workflow operators to generate task-specific agentic workflows and improve them from evaluation results.

Offers a concrete method for evolving work graphs against measurable objectives rather than intuition alone.


Multi-Agent Design: Optimizing Agents with Better Prompts and Topologies

Studies joint optimization of agent prompts and communication topology instead of tuning either component in isolation.

Shows that node behavior and graph structure interact and may need to evolve together.


Improving Factuality and Reasoning in Language Models through Multiagent Debate

Tests rounds of proposal and critique among multiple language-model instances as a way to improve factual and reasoning answers.

Supplies an empirical basis for debate-style gates while leaving room to examine correlated errors and added cost.


Improving Multi-Agent Debate with Sparse Communication Topology

Examines multi-agent debate under sparse communication structures rather than defaulting to full information exchange among every participant.

Isolates topology as a factor in debate quality and communication efficiency.


Reflexion: Language Agents with Verbal Reinforcement Learning

Lets an agent convert feedback into textual reflections stored in episodic memory and reused on later attempts.

Clarifies how a node loop can persist learning across retries without changing model weights.


CRITIC: Large Language Models Can Self-Correct with Tool-Interactive Critiquing

Uses external tools to obtain feedback that a language model can apply when critiquing and revising its outputs.

Supports verification gates grounded in observable evidence instead of another ungrounded model opinion.


Magentic-One: A Generalist Multi-Agent System for Solving Complex Tasks

Documents an orchestrator-led team of specialized agents for web, file, coding, and terminal tasks, with progress tracking and replanning.

Provides a concrete generalist topology whose role boundaries and recovery behavior can be examined as a system.


How we built our multi-agent research system

Describes a lead research agent that creates parallel subagents, delegates searches, and synthesizes their findings, including operational lessons from production.

A detailed case study of dynamic fan-out and fan-in, context separation, evaluation, and the token cost of an adaptive work graph.


CrewAI Crews

Documents role-based agent crews, assigned tasks, delegation, and sequential or hierarchical execution processes.

Offers accessible primitives for testing explicit ownership and manager-worker coordination.


OpenAI Agents SDK: Agent orchestration

Explains manager-style orchestration with agents exposed as tools and decentralized orchestration through handoffs.

Makes the centralized-versus-decentralized topology choice explicit in a production SDK.


Strands Agents: Multi-Agent Patterns

Documents several coordination shapes for composing agents, including supervisor, swarm, workflow, and graph-oriented patterns.

Lets builders compare topology choices within one SDK instead of treating one pattern as universal.


Pydantic AI: Multi-Agent Applications

Shows delegation, programmatic control flow, and graph-based state machines for composing typed Python agents.

Useful for expressing node inputs, outputs, dependencies, and orchestration boundaries in ordinary application code.


LlamaIndex: Multi-Agent Patterns

Covers agent workflow, orchestrator, and planner-oriented approaches for coordinating specialized agents.

Provides implementation patterns for choosing who owns delegation and how results return to the coordinating node.


Google ADK: Graph-based Agent Workflows

Documents declarative workflows whose nodes combine agents, tools, functions, and human input through explicit edges, typed data passing, routing, branching, state, fan-out and join, loops, escalation, and nesting.

Makes the graph load-bearing and inspectable while separating deterministic process control from model reasoning.


Microsoft Agent Framework: Workflows

Describes workflows built from executors and explicit edges, with support for branching, aggregation, state, and checkpointing.

Exposes the work graph as an inspectable program rather than hiding coordination inside prompts.


LangGraph overview

Introduces a low-level runtime for stateful agent graphs with durable execution, streaming, memory, and human intervention.

A widely used substrate for implementing explicit nodes, edges, state transitions, and resumable work graphs.


OpenAI Agents SDK: Handoffs

Documents transfers from one agent to another, including tool-shaped handoff schemas, input filters, and callbacks.

Turns an edge into an explicit contract controlling when ownership moves and what context crosses with it.


Model Context Protocol Specification 2025-11-25

Model Context Protocol project; Agentic AI Foundation

Specifies a client-server protocol through which AI applications discover and use tools, resources, prompts, and contextual data.

Standardizes capability and context edges, while remaining distinct from a protocol for delegating work between autonomous agents.


Agent2Agent Protocol Specification v1.0.0

A2A Protocol Working Group; Linux Foundation

Defines interoperable agent discovery, task lifecycle, messages, artifacts, streaming, asynchronous updates, version negotiation, and multiple protocol bindings across service boundaries.

Provides a version-pinned wire contract for cross-system handoffs where agents cannot share an in-process runtime.


LangGraph Persistence

Documents thread-scoped checkpoints, saved state, replay, state inspection, and memory storage for LangGraph runs.

Shows how graph state can become the recoverable system of record instead of living only in model context.


OpenAI Agents SDK: Sessions

Documents persistent conversation history that can be loaded and updated across repeated agent runs.

Provides a bounded mechanism for carrying state across nodes and turns without manually rebuilding every prompt.


Evaluate agent workflows

Explains how to build datasets, graders, trace-based evaluations, and reproducible checks for agent workflows.

Makes gates testable at both the final outcome and the intermediate handoff level.


Demystifying evals for AI agents

Presents practical guidance for defining tasks, outcomes, graders, and evaluation suites for agents with non-deterministic trajectories.

Helps turn vague reviewer judgments into evidence gates that can guide graph changes.


Inspect AI

Provides an open-source evaluation framework with tasks, solvers, scorers, sandboxed tools, and structured logs.

Supports reproducible gate nodes and traceable evidence for both individual agents and composed systems.


Dapr Agents introduction

Introduces an agent framework built on durable actors and workflows, with state, messaging, and recovery supplied by the Dapr runtime.

Shows how graph nodes can inherit distributed-systems durability instead of implementing recovery only in prompts.


Temporal integration for OpenAI Agents SDK

Integrates OpenAI agent runs, model calls, and tools with Temporal workflows and activities for durable execution.

Provides replay, retry, timeout, and recovery semantics beneath an agent graph without asking the model to manage them.


DBOS AI Quickstart

Shows how to place AI application steps inside durable workflows whose progress is recorded and recoverable after interruption.

Offers a compact path from an agent prototype to resumable execution with explicit step boundaries.


Restate Durable Agents

Documents durable agent patterns using persisted execution, reliable calls, retries, timers, and stateful services.

Maps common mid-graph failures to runtime guarantees rather than fragile application-level retry code.


OpenAI Agents SDK: Tracing

Documents traces and spans for agent runs, model generations, tool calls, handoffs, and guardrails.

Makes node and edge behavior inspectable so latency, failures, and expensive paths can be attributed correctly.


OpenTelemetry GenAI Semantic Conventions

Develops shared telemetry names and attributes for generative-AI model, tool, and agent operations in traces, metrics, and events.

Helps graph telemetry remain portable across runtimes and observability vendors.


Arize Phoenix: Cost Tracking

Explains how Phoenix derives and displays token usage and model cost from traced generative-AI calls.

Supports per-node and per-path cost accounting instead of treating a multi-agent run as one opaque bill.


LangSmith Observability

Documents tracing, dashboards, alerts, feedback, and evaluation views for language-model and agent applications.

Provides operational views for following execution across nodes and locating failures on the critical path.


MultiAgentBench: Evaluating Collaboration and Competition of LLM Agents

Benchmarks language-model agents in collaborative and competitive settings while examining coordination processes as well as task outcomes.

Measures properties of the team interaction that single-agent benchmarks cannot expose.


Why Do Multi-Agent LLM Systems Fail?

Provides a structured taxonomy and evaluation approach for diagnosing coordination failures in multi-agent language-model systems.

Turns reliability incidents into recurring, attributable failure classes that can guide graph redesign.


Large Language Models Cannot Self-Correct Reasoning Yet

Finds that intrinsic self-correction without reliable external feedback often fails to improve reasoning and can reduce accuracy.

Warns against using an ungrounded critic node as evidence simply because it is separate from the producing node.


Towards a Science of Scaling Agent Systems

Studies how agent-system performance changes across tasks, models, coordination structures, and scaling choices under controlled experiments.

Tests the assumption that adding agents reliably helps and frames scaling as an empirical topology decision.


Single-Agent LLMs Outperform Multi-Agent Systems on Multi-Hop Reasoning Under Equal Thinking Token Budgets

Compares single-agent and multi-agent approaches to multi-hop reasoning while holding the total thinking-token budget constant.

Provides the cost-controlled baseline needed before claiming that coordination, rather than extra inference, caused an improvement.


From Loop Engineering to Graph Engineering?

Frames the shift as loop architecture: networks of improvement cycles that monitor, feed, constrain, and correct one another, with reliability located in their edges.

Adds the grounding requirement missing from topology-only accounts: independent counter-metrics, frozen tests or rules, external anchors, and human ownership of root objectives.


A Multi-Level Organization for Problem Solving Using Many, Diverse, Cooperating Sources of Knowledge

Presents the Hearsay-II multi-level blackboard, where independent knowledge sources react to shared hypotheses, create explicit structural dependencies, and verify or revise one another's contributions.

Provides an early architecture for loosely coupled specialist nodes coordinating through inspectable shared state instead of direct all-to-all calls.


The Contract Net Protocol: High-Level Communication and Control in a Distributed Problem Solver

Defines a negotiation protocol in which managers announce tasks, potential contractors bid, and awards establish temporary problem-solving relationships.

Supplies the classic contract for capability-aware delegation and auditable assignment edges between autonomous nodes.


The Five Ws of Multi-Agent Communication: Who Talks to Whom, When, What, and Why – A Survey from MARL to Emergent Language and LLMs

Transactions on Machine Learning Research

Jingdi Chen; Hanqing Yang; Zongjun Liu; Carlee Joe-Wong

Synthesizes multi-agent communication across reinforcement learning, emergent language, and LLM systems through sender, recipient, timing, content, and purpose decisions.

Provides a design-oriented map for engineering edge selection, message timing, payloads, grounding, scalability, and interpretability.


Scaling Large Language Model-based Multi-Agent Collaboration

Chen Qian; Zihao Xie; YiFei Wang; Wei Liu; Kunlun Zhu; Hanchen Xia; Yufan Dang; Zhuoyun Du; Weize Chen; Cheng Yang; Zhiyuan Liu; Maosong Sun

Introduces MacNet, a DAG-based collaboration architecture executed in topological order, and studies communication structure while scaling experiments beyond 1,000 agents.

Makes topology a causal scaling variable rather than assuming that larger teams or denser communication automatically help.


MAS-Orchestra: Understanding and Improving Multi-Agent Reasoning Through Holistic Orchestration and Controlled Benchmarks

Formulates orchestration as reinforcement-learned generation of a complete multi-agent program and evaluates it across controlled dimensions including depth, horizon, breadth, parallelism, and robustness.

Tests when whole-system graph structure helps instead of attributing gains to coordination without controlled task evidence.


CARD: Towards Conditional Design of Multi-agent Topological Structures

Generates communication graphs conditioned on agent roles, models, tools, and data sources, and adapts topology as task resources change.

Treats the available capabilities and directed edges as a versionable organizational artifact rather than a fixed team template.


ResMAS: Resilience Optimization in LLM-based Multi-agent Systems

Learns task-specific resilient communication topologies and topology-aware prompts after measuring how graph structure and node instructions affect performance under agent failures and other perturbations.

Moves resilience from reactive recovery into the design of the graph itself and evaluates transfer to new tasks and models.


EvoMAS: Evolutionary Generation of Multi-Agent Systems

Evolves structured multi-agent configurations through trace-guided mutation, crossover, selection, and an experience memory across reasoning, coding, and tool-use tasks.

Shows how an inspectable team specification can evolve from execution evidence while retaining executability and runtime robustness.


Understanding the Information Propagation Effects of Communication Topologies in LLM-based Multi-Agent Systems

Causally studies correct and erroneous information propagation across communication densities and finds that moderately sparse structures can preserve useful diffusion while suppressing errors.

Provides evidence against defaulting to dense graphs and links topology decisions to measured error amplification.


MASFactory: A Graph-centric Framework for Orchestrating LLM-Based Multi-Agent Systems with Vibe Graphing

Compiles natural-language intent into an editable workflow specification and executable directed graph, with reusable components, topology preview, runtime tracing, multimodal messages, and human interaction.

Provides a direct implementation path from an inspectable organizational graph to execution and evaluates it on seven public benchmarks.


AutoGen GraphFlow (Workflows)

Implements directed multi-agent execution graphs with sequential, parallel, conditional, fan-in, and cyclic paths, edge conditions, activation groups, safe loop exits, and separately configurable message filtering. The feature is explicitly experimental.

Distinguishes the execution graph from the message graph, exposing both who acts next and what context each agent receives.


Model Context Protocol: Tasks

Specifies experimental durable asynchronous request state machines with capability negotiation, polling, deferred results, progress, input-required states, cancellation, TTLs, and task-message correlation.

Turns a remote tool or context edge into a recoverable task contract that can outlive one synchronous request.


Secure Low-Latency Interactive Messaging (SLIM)

IETF Datatracker; individual Internet-Draft

Luca Muscariello; Michele Papalini; Mauro Sardara; Sam Betts

Proposes a transport layer for A2A and MCP using gRPC over HTTP/2 and HTTP/3 with stream multiplexing, flow control, group communication, native RPC semantics, and MLS end-to-end encryption. It is an individual informational Internet-Draft with no formal IETF standing.

Adds a concrete secure transport substrate for high-volume graph edges that must cross process and organizational boundaries.


Accelerating the Adoption of Software and Artificial Intelligence Agent Identity and Authorization

Harold Booth; William Fisher; Ryan Galluzzo; Joshua Roberts

Outlines considerations and open questions for standards-based identity, authorization, auditing, and non-repudiation when software and AI agents access enterprise systems and take actions. The concept paper remains an initial public draft under review.

Grounds graph roles and permissions in identity practice so delegation does not silently transfer more authority than an edge contract allows.


Google ADK: Artifacts

Defines named, automatically versioned binary work products that agents and tools can save, load, list, and exchange within session-scoped or persistent user-scoped namespaces.

Provides explicit, inspectable edge artifacts instead of forcing large or structured outputs through conversational context.


LEGOMem: Modular Procedural Memory for Multi-agent LLM Systems for Workflow Automation

Dongge Han; Camille Couturier; Daniel Madrigal Diaz; Xuchao Zhang; Victor Rühle; Saravan Rajmohan

Decomposes execution trajectories into reusable procedural memories and allocates them to an orchestrator and specialist agents for workflow automation.

Shows how durable experience can improve decomposition and delegation without collapsing every node's memory into one undifferentiated store; the selected artifact is a three-page extended abstract.


When Agents Go Rogue: Activation-Based Detection of Malicious Behaviors in Multi-Agent Systems

Evaluates activation-space detection and restorative steering of compromised agents across five attack scenarios, multiple models, and synchronous and asynchronous multi-agent interactions.

Tests a topology-agnostic gate for locating and repairing a malicious node when its messages appear superficially benign.


DoVer: Intervention-Driven Auto Debugging for LLM Multi-Agent Systems

Tests failure hypotheses by editing messages or plans and measuring whether each intervention repairs the outcome or advances execution in branching multi-agent traces.

Turns graph debugging into causal repair experiments instead of relying on plausible but unverified post-hoc explanations.


Microsoft Agent Framework: Durable Extension

Adds persisted sessions, checkpointed progress, failure recovery, external-event waits, and distributed hosting to agents, multi-agent orchestrations, and graph workflows. The documented packages remain prerelease.

Shows how an agent graph can resume without losing context or repeating completed work after interruption.


Breaking and Fixing Defenses Against Control Flow Hijacking in Multi-Agent Systems

Rishi Dev Jha; Harold Triedman; Justin Wagle; Vitaly Shmatikov

Demonstrates attacks against alignment-check defenses and introduces ControlValve, which generates permitted control-flow graphs and enforces least privilege for each agent invocation.

Makes invocation authority and contextual permissions explicit on every edge instead of trusting a separate checker that can also be hijacked.


BAMAS: Structuring Budget-Aware Multi-Agent Systems

Liming Yang; Junyu Luo; Xuanzhe Liu; Yiling Lou; Zhenpeng Chen

Selects an LLM team with integer programming and then learns its collaboration topology under an explicit budget, reporting comparable performance with cost reductions of up to 86% on three tasks.

Jointly engineers node selection, edge structure, and spend instead of optimizing quality while treating inference cost as an afterthought.


AgentXRay: White-Boxing Agentic Systems via Workflow Reconstruction

Ruijie Shi; Houbin Zhang; Yuecheng Han; Yuheng Wang; Jingru Fan; Runde Yang; Yufan Dang; Huatao Li; Dewen Liu; Yuan Cheng; Chen Qian

Reconstructs an editable explicit stand-in workflow for a black-box agentic system from input-output behavior using iterative search and evaluation.

Offers a path to inspect, compare, and modify systems whose load-bearing workflow is hidden behind an API.


SILO-BENCH: A Scalable Environment for Evaluating Distributed Coordination in Multi-Agent LLM Systems

Benchmarks free-form coordination under information silos across 30 exact-answer tasks, three communication protocols, six agent scales, and three models while recording success, tokens, and communication density.

Tests whether more nodes and denser edges overcome distributed information constraints under explicit coordination and cost measures.


Gaia2: Benchmarking LLM Agents on Dynamic and Asynchronous Environments

Evaluates agents in asynchronous simulated environments across execution, search, ambiguity, adaptation, temporal reasoning, noise, and agent-to-agent collaboration, with action-level verifiers and structured traces.

Makes delays, environmental change, peer communication, and externally checked writes first-class work-graph conditions.


TAMAS: Benchmarking Adversarial Risks in Multi-Agent LLM Systems

Ishan Kavathekar; Hemang Jain; Ameya Rathod; Ponnurangam Kumaraguru; Tanuja Ganu

Provides five scenarios with 300 adversarial instances, six attack types, 211 tools, 100 harmless tasks, and multiple AutoGen and CrewAI interaction configurations, plus an Effective Robustness Score.

Evaluates whether safety controls preserve useful work while attacks exploit the distinctive trust and communication surfaces of a multi-agent graph.


Seeing the Whole Elephant: A Benchmark for Failure Attribution in LLM-based Multi-Agent Systems

Introduces TraceElephant with full execution traces and reproducible environments for attributing failures to responsible agents and decisive steps.

Measures causal diagnosis over nodes, messages, plans, and dependencies instead of evaluating only the final team output.


Creating AI agent solutions for warehouse data access and security

Can Lin; Uday Ramesh Savagaonkar; Iuliu Rus; Komal Mangtani

Describes collaborating data-user and data-owner agents, specialized subagents, triage, permission negotiation, human oversight, access budgets, analytical risk rules, output guardrails, traces, and daily regression evaluation.

Shows plural bounded agency governed by independent rule-based gates rather than relying on model judgment for security decisions.


How Meta Used AI to Map Tribal Knowledge in Large-Scale Data Pipelines

Krishna Ganeriwal; Plawan Rath; Ashwini Verma

Reports a staged swarm of more than 50 explorer, analyst, writer, critic, fixer, upgrader, tester, and gap-filling tasks, with repeated review rounds and recurring automated refresh runs.

Provides a concrete fan-out, critique, repair, integration, and recurrence graph with explicit artifacts and quality gates; efficiency figures are company-reported and preliminary.


Solving the Identity Crisis for AI Agents

Matt Mathew; Prasad Borole; Meng Huang; Sergey Burykin; Gaurav Goel; Bayard Walsh

Describes an internal agent mesh with registered identities, SPIRE-backed workload attestation, short-lived audience-scoped tokens for every hop, actor-chain provenance, MCP gateway enforcement, and a standardized A2A client.

Treats identity, delegated authority, and provenance as mandatory edge state across a multi-agent graph; adoption and latency metrics are company-reported.


Dynamic Generation of Multi LLM Agents Communication Topologies with Graph Diffusion Models

Introduces Guided Topology Diffusion, which iteratively synthesizes sparse, task-adaptive communication graphs using a proxy model for objectives such as accuracy, utility, and cost.

Treats topology as a multi-objective, per-task design artifact rather than a static collaboration template.


Topology Matters: Measuring Memory Leakage in Multi-Agent LLMs

Measures private-information leakage across six communication topologies, agent counts, and attacker-target placements, finding higher leakage with denser connectivity, shorter graph distance, and greater target centrality.

Makes privacy a measurable consequence of edge structure and node placement, motivating topology-aware access controls.


Diversity Collapse in Multi-Agent LLM Systems: Structural Coupling and Collective Failure in Open-Ended Idea Generation

Studies multi-agent ideation across model, cognition, and system levels, finding diminishing group-size returns, authority effects, and faster premature convergence under dense communication.

Shows that interaction can contract a search space, so graph designs for exploration must preserve independence and meaningful disagreement.


AgentDropout: Dynamic Agent Elimination for Token-Efficient and High-Performance LLM-Based Multi-Agent Collaboration

Zhexuan Wang; Yutong Wang; Xuebo Liu; Liang Ding; Miao Zhang; Jie Liu; Min Zhang

Optimizes communication-graph adjacency matrices across collaboration rounds to remove redundant agents and messages, reducing both prompt and completion token consumption in its evaluations.

Makes node participation and edge density explicit cost-quality decisions instead of assuming every role should run on every task.


Collab-Overcooked: Benchmarking and Evaluating Large Language Models as Collaborative Agents

Haochen Sun; Shuwen Zhang; Lujie Niu; Lei Ren; Hao Xu; Hao Fu; Fangkun Zhao; Caixia Yuan; Xiaojie Wang

Provides 30 open-ended cooperative tasks and process-oriented measures for goal interpretation, active collaboration, communication, and continuous adaptation across 13 language models.

Distinguishes reaching an answer from coordinating well, exposing collaboration failures that final-outcome metrics can hide.


Red-Teaming LLM Multi-Agent Systems via Communication Attacks

Pengfei He; Yuping Lin; Shen Dong; Han Xu; Yue Xing; Hui Liu

Introduces an Agent-in-the-Middle attack that intercepts and manipulates inter-agent messages, evaluated across multiple frameworks, communication structures, and applications.

Shows that graph edges can compromise the whole system without altering its nodes, making message integrity and provenance part of the handoff contract.


Multi-agent Architecture Search via Agentic Supernet

Guibin Zhang; Luyang Niu; Junfeng Fang; Kun Wang; Lei Bai; Xiang Wang

Represents possible agentic architectures as a probabilistic supernet and samples query-dependent systems with tailored language-model calls, tool calls, and token costs across six benchmarks.

Replaces a one-size-fits-all graph with per-query architecture and resource allocation while keeping the design space explicit.


Unlocking the Power of Multi-Agent LLM for Reasoning: From Lazy Agents to Deliberation

Identifies lazy-agent behavior in which one role dominates a nominally collaborative system, then measures causal influence and uses verifiable rewards to encourage deliberation and selective reasoning restarts.

Requires builders to verify that each node contributes causal value rather than allowing a multi-agent graph to collapse into one effective agent.


Cooperation, Competition, and Maliciousness: LLM-Stakeholders Interactive Negotiation

Sahar Abdelnabi; Amr Gomaa; Sarath Sivaprasad; Lea Schönherr; Mario Fritz

Provides scorable, multi-agent, multi-issue negotiation games with metrics for task performance and role alignment, including cooperative, competitive, greedy, and adversarial participants.

Tests communication and collective decisions when graph nodes hold conflicting objectives or attempt manipulation rather than cooperating by default.


OWASP Top 10 for Agentic Applications for 2026

OWASP GenAI Security Project; Agentic Security Initiative

Provides a globally peer-reviewed operational framework for critical risks in autonomous and agentic applications, developed with contributions from more than 100 security experts, researchers, and practitioners.

Supplies a practical threat checklist for node authority, tool permissions, memory provenance, inter-agent trust, and cascading failures across an agent graph.


AMAS: Adaptively Determining Communication Topology for LLM-based Multi-agent System

Hui Yi Leong; Yuheng Li; Yuqing Wu; Wenwen Ouyang; Wei Zhu; Jiechao Gao; Wei Han

Introduces a dynamic graph selector that uses lightweight LLM adaptation to choose task-specific communication structures and route each query through a matching agent pathway.

Operationalizes topology as an input-conditioned decision rather than a fixed template; evidence is currently concentrated in question answering, mathematics, and code generation.


Collaboration-mode, role, and model routing

MasRouter: Learning to Route LLMs for Multi-Agent Systems

Yanwei Yue; Guibin Zhang; Boyang Liu; Guancheng Wan; Kun Wang; Dawei Cheng; Yiyan Qi

Defines multi-agent system routing as a joint decision over collaboration mode, role allocation, and language-model selection, implemented with a cascaded controller that progressively constructs a task-specific system.

Makes node roles, model assignment, and whether collaboration is needed explicit routing decisions with measurable cost-quality trade-offs.


MOC: Multi-Order Communication in LLM-based Multi-Agent Systems

Yao Guan; Lin Wang; Zhihui Lu; Ziyi Wang; Wenzhu Yan; Qiang Duan

Constructs structured multi-order evidence streams so agents can receive relevant information from multiple upstream hops, then applies semantic-topological merging under token constraints.

Shows that graph engineering includes what evidence survives across paths, not only which nodes and edges exist; it improves communication over a supplied topology rather than selecting that topology.


Hierarchical node and topology optimization

HieraMAS: Optimizing Intra-Node LLM Mixtures and Inter-Node Topology for Multi-Agent Systems

Models each functional role as a supernode containing heterogeneous language models in a propose-synthesis structure, then uses multi-level reward attribution and graph classification to select the inter-supernode topology.

Jointly engineers node composition, role capability, credit assignment, and communication edges instead of optimizing each dimension independently.


Learning to Share: Selective Memory for Efficient Parallel Agentic Systems

Joseph Fioresi; Parth Parag Kulkarni; Ashmal Vayani; Song Wang; Mubarak Shah

Adds a global memory bank to parallel agent teams and trains an admission controller with stepwise reinforcement learning and usage-aware credit assignment to retain reusable intermediate work.

Treats cross-team memory writes as governed graph operations that can reduce duplicate work while limiting indiscriminate context growth.


Accelerating Language Model Workflows with Prompt Choreography

Executes multi-agent workflows with a dynamic global key-value cache in which each call can attend to a reordered subset of previously encoded messages, including parallel branches.

Makes workflow dependencies and reusable message state explicit execution concerns; its primary result concerns speed, and cache reuse can alter model behavior.


Can LLMs Help You at Work? A Sandbox for Evaluating LLM Agents in Enterprise Environments

Harsh Vishwakarma; Ankush Agarwal; Ojas Patil; Chaitanya Devaguptapu; Mahesh Chandran

Introduces EnterpriseBench with 500 tasks across software engineering, HR, finance, and administration, including fragmented data, access-control hierarchies, and cross-functional workflows.

Tests work graphs that retrieve, modify, and transfer artifacts across services while respecting authority boundaries; the organization and services are simulated.


ToolSandbox: A Stateful, Conversational, Interactive Evaluation Benchmark for LLM Tool Use Capabilities

Jiarui Lu; Thomas Holleis; Yizhe Zhang; Bernhard Aumayer; Feng Nan; Haoping Bai; Shuang Ma; Shen Ma; Mengyu Li; Guoli Yin; Zirui Wang; Ruoming Pang

Evaluates stateful tool execution, implicit dependencies between tools, on-policy user interaction, and intermediate and final milestones over arbitrary trajectories.

Transfers milestone and state-transition testing to graph prerequisites, although the evaluated system is an agent-user-tool loop rather than an agent-agent topology.


AgentBoard: An Analytical Evaluation Board of Multi-turn LLM Agents

Chang Ma; Junlei Zhang; Zhihao Zhu; Cheng Yang; Yujiu Yang; Yaohui Jin; Zhenzhong Lan; Lingpeng Kong; Junxian He

Unifies partially observable, multi-round agent environments and adds a fine-grained progress-rate metric plus interactive trajectory analysis beyond final success.

Supplies milestone-level evaluation that can localize incomplete work, while its primarily single-agent tasks do not identify the responsible graph component by themselves.


Agent Security Bench (ASB): Formalizing and Benchmarking Attacks and Defenses in LLM-based Agents

Hanrong Zhang; Jingyuan Huang; Kai Mei; Yifei Yao; Zhenting Wang; Chenlu Zhan; Hongwei Wang; Yongfeng Zhang

Benchmarks prompt injection, memory poisoning, backdoors, mixed attacks, and defenses across 10 scenarios, more than 400 tools, 13 model backbones, and seven metrics.

Maps security failures to prompts, plans, tools, and memory surfaces that graph designs must isolate separately; inter-agent trust propagation is outside its main evaluation target.


AgentDojo: A Dynamic Environment to Evaluate Prompt Injection Attacks and Defenses for LLM Agents

Edoardo Debenedetti; Jie Zhang; Mislav Balunovic; Luca Beurer-Kellner; Marc Fischer; Florian Tramèr

Provides an extensible adversarial environment with 97 realistic tasks and 629 security test cases for agents executing tools over untrusted data.

Tests the instruction-data boundary that every external-input and artifact edge must preserve; compromised peer-agent messages require separate evaluation.


AgentHarm: A Benchmark for Measuring Harmfulness of LLM Agents

Maksym Andriushchenko; Alexandra Souly; Mateusz Dziemian; Derek Duenas; Maxwell Lin; Justin Wang; Dan Hendrycks; Andy Zou; J. Zico Kolter; Matt Fredrikson; Yarin Gal; Xander Davies

Evaluates refusal and retained task capability on 110 explicitly malicious multi-stage agent tasks with 440 augmented variants across 11 harm categories.

Tests whether safety gates reject prohibited work and stop a compromised node from completing a harmful path; the score is not a general measure of agent-system safety.


IPIGuard: A Novel Tool Dependency Graph-Based Defense Against Indirect Prompt Injection in LLM Agents

Hengyu An; Jinghuai Zhang; Tianyu Du; Chunyi Zhou; Qingming Li; Tao Lin; Shouling Ji

Models task execution as traversal over a planned Tool Dependency Graph and separates action planning from interaction with untrusted external data.

Shows how structural constraints on allowed tool edges can block unauthorized actions instead of relying only on prompts or classifiers.


Agent identity and delegated authorization

Identity Management for Agentic AI: The new frontier of authorization, authentication, and security for an AI agent world

OpenID Foundation Artificial Intelligence Identity Management Community Group

Maps identity, authentication, delegated authority, consent, governance, and accountability gaps for autonomous agents against OAuth and OpenID Connect foundations.

Provides a standards-grounded vocabulary for identity-bearing nodes and auditable delegation across agent and tool edges; it is a non-normative landscape whitepaper, not a protocol.


Open Agentic Schema Framework (OASF) v1.1.0

Defines versioned schemas and taxonomies for agent identity metadata, capabilities, skills, modules, interactions, and discovery records, including MCP and A2A alignment modules.

Gives graph builders a portable node descriptor for capability-based discovery and routing validation; it describes capabilities but does not execute a graph or authorize an edge.


PROV-DM: The PROV Data Model

Defines entities, activities, agents, derivation, attribution, responsibility, bundles, and collections for interoperable provenance records.

Maps artifacts, execution steps, and responsible nodes into a portable lineage model; storage, access control, and cryptographic integrity remain implementation concerns.


in-toto: Providing farm-to-table guarantees for bits and bytes

Santiago Torres-Arias; Hammad Afzali; Trishank Karthik Kuppusamy; Reza Curtmola; Justin Cappos

Introduces signed material and product links for supply-chain steps and verifies them against an expected layout, supported by analysis of 30 historical compromises and deployed integrations.

Supplies a transferable receipt pattern that binds each artifact transformation to an authorized step and identity; it verifies process integrity, not semantic correctness.


Serverless Workflow Specification v1.0.0

Open Workflow Specification, Cloud Native Computing Foundation

Defines a vendor-neutral workflow language with sequential and concurrent tasks, event correlation, service calls, error handling, retries, and timeouts.

Provides an inspectable execution contract for production work graphs; conformance does not itself supply a durable runtime, an agent protocol, or model-level correctness.


Are More LLM Calls All You Need? Towards the Scaling Properties of Compound AI Systems

Lingjiao Chen; Jared Davis; Boris Hanin; Peter Bailis; Ion Stoica; Matei Zaharia; James Zou

Analyzes Vote and Filter-Vote compound systems and finds that performance can rise and then fall as the number of language-model calls increases because query difficulty is heterogeneous.

Bounds claims that adding calls, voters, or nodes automatically improves a system; the experiments cover simple aggregation systems rather than rich agent organizations.


Verification-Aware Planning for Multi-Agent Systems

Tianyang Xu; Dan Zhang; Kushan Mitra; Estevam Hruschka

Introduces VeriMAP, which decomposes tasks into a dependency graph and attaches planner-defined Python and natural-language verification functions to subtasks before execution.

Makes acceptance criteria part of the work graph so handoff failures can trigger local repair instead of surfacing only in a final answer.


AIPOM: Agent-aware Interactive Planning for Multi-Agent Systems

Hannah Kim; Kushan Mitra; Chen Shen; Dan Zhang; Estevam Hruschka

Presents conversational and graph-based interfaces for inspecting, editing, and collaboratively guiding plans in orchestrated multi-agent systems.

Treats the work graph as a human-legible control surface; its non-autonomous agents execute assigned tasks, so it is a planning substrate rather than a complete agent organization.


Build reliable multi-agent applications with ADK Go 2.0

Toni Klopfenstein; Sampath Kumar Maddula

Documents a graph-based multi-agent workflow engine with typed nodes, conditional edges, fan-out and fan-in, nested graphs, cycles, retries, durable human input, state, and unified telemetry.

Provides a first-party implementation of explicit, resumable work graphs while showing that function and tool nodes remain distinct from agent nodes.


AgentNet: Decentralized Evolutionary Coordination for LLM-based Multi-Agent Systems

Yingxuan Yang; Huacan Chai; Shuai Shao; Yuanyi Song; Siyuan Qi; Renting Rui; Weinan Zhang

Organizes specialized agents in a decentralized DAG, uses retrieval-backed local experience for capability refinement, and adapts routing without a single central orchestrator.

Offers a contrasting topology for settings where central coordination is a bottleneck or trust boundary; its reported evidence is concentrated in reasoning and coding tasks.


ETAS: An Effect-Typed Language for Agent Systems

Huiri Tan; Yikun Wang; Puyang Zhang; Shangyu Li; Jiasi Shen

Defines a language in which agents, tools, typed memory, approvals, policies, effects, and execution traces are semantic program elements, with static obligations and runtime monitors.

Provides a transferable contract model for authorizing and auditing node actions before and during execution; it is a new preprint and not yet deployment evidence.


The Shared Discovery Paradox: How a One-Answer Rule Turns Better Information into Worse Search

Uses an exactly solvable multi-searcher benchmark to show that pooling information into one repeated recommendation can improve belief accuracy while sharply reducing collective discovery coverage.

Separates information quality from allocation policy and warns that consensus edges can collapse parallel exploration unless a coordinator preserves a portfolio of actions.


When Do Multi-Agent Systems Help? An Information Bottleneck Perspective

Wendi Yu; Lianhao Zhou; Xiangjue Dong; Sai Sudarshan Barath; Declan Staunton; Byung-Jun Yoon; Xiaoning Qian; James Caverlee; Shuiwang Ji

Formalizes bounded inter-agent relays as an information bottleneck and reports 18 controlled experiments across five benchmarks and three model scales.

Explains when isolated contexts and compressed handoffs save useful context and when they discard task-relevant information, providing a direct test for whether a graph earns its edge losses.


Precise but Uncoupled: Reviewer Precision Does Not Guarantee Critique Uptake in Multi-Agent Math Reasoning

Chih-Hsuan Yang; Jingyan Jiang; Vikram Vasudevan; Cheng-Hau Yang; Huihuo Zheng; Le Chen; Eliu A. Huerta; Venkatram Vishwanath; Ian T. Foster; Rajeev Thakur

Evaluates 4,181 verifier-grounded math problems and finds that a precise reviewer can still yield weak repair when the protocol does not carry useful critique into the next candidate.

Shows that a verifier node is insufficient by itself: the outgoing edge must couple accepted evidence to a concrete state change or retry action.


Grammar Search for Multi-Agent Systems

Mayank Singh; Vikas Yadav; Shiva Krishna Reddy Malay; Shravan Nayak; Sai Rajeswar; Sathwik Tejaswi Madhusudhan; Eduardo Blanco

Searches a fixed grammar of composable multi-agent components to construct modular, interpretable organizations at lower search cost than unconstrained code generation.

Makes the agent-system design space explicit and auditable while retaining automated search over roles, operators, and coordination structure.


Graph-GRPO: Stabilizing Multi-Agent Topology Learning via Group Relative Policy Optimization

Yueyang Cang; Xiaoteng Zhang; Erlu Zhao; Zehua Ji; Yuhang Liu; Yuchen He; Zhiyuan Ning; Chen Yijun; Wenge Que; Li Shi

Samples groups of query-specific communication graphs and uses relative rewards to assign edge-level credit while training a topology-generating policy.

Addresses unstable topology learning with explicit graph samples and localized credit rather than treating orchestration as an opaque prompt update.


AgentSlimming: Towards Efficient and Cost-Aware Multi-Agent Systems

Yulang Chen; Haoxuan Peng; Jinyan Liu; Zichen Wen; Dongrui Liu; Linfeng Zhang

Compresses graph-structured agent workflows using centrality and approximate Shapley importance, then validates agent removal and cheaper-model substitution against the original system.

Provides a measured way to reduce nodes and spend without assuming every role contributes equally or that a smaller graph preserves behavior automatically.


TopoDIM: One-shot Topology Generation of Diverse Interaction Modes for Multi-Agent Systems

Rui Sun; Jie Ding; Chenghua Gong; Tianjun Gu; Yihang Jiang; Juyuan Zhang; Liming Pan; Linyuan Lü

Generates heterogeneous decentralized communication topologies in one pass, replacing repeated coordination rounds with a task-conditioned interaction structure.

Expands topology design beyond homogeneous or fully connected teams while directly evaluating the quality and token cost of the generated graph.


EvoHyper: Evolving Hypergraph Topologies for Unified Collaboration in Multi-Agent Communication

Heng Zhang; Yihao Zhong; Lubin Gan; Zhihe Chen; Jiajun Wu; Yuling Shi; Xiaodong Gu; Hao Zhang; Haochen You; Jin Huang

Uses evolving hyperedges to bind groups of agents to shared memory while a controller creates, updates, and merges collaboration units during execution.

Models group communication as a first-class structure and joins topology evolution with explicit shared-state ownership instead of reducing every exchange to pairwise chat.


RouterHGC: Optimized Router for LLM-based Multi-Agent Systems via Heterogeneous Graph Contrastive Learning

Yitao Xiao; Shaoyong Guo; Guoming Yang; Qingnan Wang; Yinlin Ren; Xuesong Qiu; Qi Feng

Represents queries, collaboration modes, roles, and language models as heterogeneous nodes and learns cost-performance routing relationships with graph contrastive learning.

Treats the agent organization itself as the graph under optimization and exposes model, role, mode, and budget choices within one routing decision.


LLM-as-Scheduler: Agentic Workflow Dynamic Scheduling

Dawei Xiang; Kexin Chu; Wenyan Xu; Wenhui Zhang; Wei Zhang

Dynamically selects query-specific paths through a workflow DAG, including early exit, verification, repair, and rerouting decisions made during execution.

Separates the reusable work graph from the runtime path and supplies concrete control points for budgets, validation, and local recovery.


Learning Optimal Message Representations for Agentic Communication

Shashwat Gupta; Anson Bastos; Mayukh Das; Supriyo Ghosh; Nagarajan Natarajan; Chetan Bansal; Saravan Rajmohan

Models the choice of inter-agent message representation as an expanding Markov decision process that can select natural-language or structured protocols at each exchange.

Makes payload format an adaptive edge policy rather than a global convention, clarifying when structure, compression, or expressiveness should dominate.


AgentAsk: Multi-Agent Systems Need to Ask

Bohan Lin; Kuo Yang; Zelin Tan; Yingchuan Lai; Chen Zhang; Guibin Zhang; Xinlei Yu; Miao Yu; Xu Wang; Yudong Zhang; Yang Wang

Defines an edge-level handoff-error taxonomy and adds selective clarification questions at critical exchanges where transferred information is ambiguous or incomplete.

Turns clarification into an explicit recovery action for communication-contract failures instead of letting uncertainty silently propagate downstream.


Towards Self-Improving Error Diagnosis in Multi-Agent Systems

Jiazheng Li; Emine Yilmaz; Bei Chen; Thu Le

Detects local anomalies, traces backward to decisive failures, tests diagnostic hypotheses with tools, and retains only execution-verified diagnostic memories.

Combines trace localization, active validation, and durable learning so a diagnostic node improves from evidence rather than storing unverified explanations.


CORBA: Contagious Recursive Blocking Attacks on Multi-Agent Systems Based on Large Language Models

Zhenhong Zhou; Zherui Li; Jie Zhang; Yuanhe Zhang; Kun Wang; Yang Liu; Qing Guo

Formalizes attacks that deform communication topology into cycles or recursively expanding exchanges, blocking useful collaboration while exhausting system resources.

Shows that edge activation and termination policies are security boundaries, not only scheduling details, and motivates cycle and budget guards.


CIA: Inferring the Communication Topology from LLM-based Multi-Agent Systems

Yongxuan Wu; Xixun Lin; He Zhang; Nan Sun; Kun Wang; Chuan Zhou; Shirui Pan; Yanan Cao

Infers hidden communication topology from black-box multi-agent systems using adversarial queries and semantic correlations among observed responses.

Establishes topology confidentiality as an engineering property and demonstrates that apparently private coordination structure can leak through behavior.


ACIArena: Toward Unified Evaluation for Agent Cascading Injection

Hengyu An; Minxi Li; Jinghuai Zhang; Naen Xu; Chunyi Zhou; Changjiang Li; Xiaogang Xu; Tianyu Du; Shouling Ji

Evaluates cascading injection through external inputs, agent profiles, and inter-agent messages across six implementations and 1,356 attack cases.

Measures how topology, roles, and interaction design affect propagation instead of treating prompt injection as an isolated single-node event.


BlindGuard: Safeguarding LLM-based Multi-Agent Systems under Unknown Attacks

Rui Miao; Yixin Liu; Yili Wang; Xu Shen; Yue Tan; Yiwei Dai; Shirui Pan; Xin Wang

Learns normal individual, neighborhood, and global interaction behavior without attack labels, then detects malicious agents through corruption-guided contrastive learning.

Adds graph-aware anomaly detection for attacks that were absent from training and distinguishes local behavior from neighborhood and system-wide patterns.


Explainable and Fine-Grained Safeguarding of LLM Multi-Agent Systems via Bi-Level Graph Anomaly Detection

Junjun Pan; Yixin Liu; Rui Miao; Kaize Ding; Yu Zheng; Quoc Viet Hung Nguyen; Alan Wee-Chung Liew; Shirui Pan

Detects sentence- and token-level anomalies over multi-agent interaction graphs and attributes suspicious tokens to support finer-grained explanations of compromised exchanges.

Connects graph-level protection to actionable message evidence rather than returning only an opaque risk score for an entire agent or run.


Identifying Collective Intelligence Factor in LLM Agent Groups for Generalizable Multi-Agent System Design

Zhilun Zhou; Zihan Liu; Jiahe Liu; Yihan Wang; Qingyu Shao; Fengli Xu; Depeng Jin; Yong Li

Studies 108 agent groups varying team size, model composition, and communication topology, then derives a factor intended to predict transferable system designs.

Moves evaluation beyond one benchmark score by testing whether measurable group properties forecast performance across designs and tasks.


Benefits and Limitations of Communication in Multi-Agent Reasoning

Michael Rizvi-Martel; Satwik Bhattamishra; Neil Rathi; Guillaume Rabusseau; Michael Hahn

Derives bounds connecting agent count and the quantity and structure of communication to exact reasoning and speedups, then tests the tradeoffs on controlled language-model tasks.

Supplies principled limits for node count and bandwidth decisions and identifies regimes where communication helps or becomes an intrinsic bottleneck.


Agents Under Siege: Breaking Pragmatic Multi-Agent LLM Systems with Optimized Prompt Attacks

Rana Shahroz; Zhen Tan; Sukwon Yun; Charles Fleming; Tianlong Chen

Optimizes attack placement across latency- and bandwidth-constrained agent networks using graph-flow formulations to disrupt multi-agent task completion.

Makes topology part of the adversary model and tests how limited attack budgets exploit particular communication paths and bottlenecks.


AgentsNet: Coordination and Collaborative Reasoning in Multi-Agent LLMs

arXiv; ICML 2025 Workshop on Collaborative and Federated Agentic Workflows

Florian Grötschla; Luis Müller; Jan Tönshoff; Mikhail Galkin; Bryan Perozzi

Evaluates local messaging and learned coordination protocols on distributed graph problems over explicit network topologies, with experiments scaling to 100 agents.

Provides unusually direct evidence about decentralized protocol formation and topology-aware reasoning; the selected artifact remains a preprint and workshop contribution.


LLM-Coordination: Evaluating and Analyzing Multi-agent Coordination Abilities in Large Language Models

Saaket Agashe; Yue Fan; Anthony Reyna; Xin Eric Wang

Evaluates agentic play in four pure-coordination games and 198 questions covering environment comprehension, theory of mind, and joint planning.

Separates coordination capability into measurable components and partner-generalization tests, although communication topology is not its central experimental variable.


Graph-of-Agents: A Graph-based Framework for Multi-Agent LLM Collaboration

Sukwon Yun; Jie Peng; Pingzhi Li; Wendong Fan; Jie Chen; James Y. Zou; Guohao Li; Tianlong Chen

Selects relevant agents from model cards, constructs directed edges from response relevance, performs forward and reverse message passing, and pools the revised answers.

Offers an end-to-end graph construction and aggregation method in which node selection, edge order, and communication direction are explicit design choices.


Stochastic Self-Organization in Multi-Agent Systems

Nurbek Tastan; Samuel Horváth; Karthik Nandakumar

Builds a response-conditioned directed acyclic graph from approximate peer-contribution scores and updates the communication structure across collaboration rounds.

Adapts topology from observed agent behavior without a separate judge, pretrained generator, or fixed graph, while retaining stable acyclic message flow.


GraphPlanner: Graph Memory-Augmented Agentic Routing for Multi-Agent LLMs

Tao Feng; Haozhen Zhang; Zijie Lei; Peixuan Han; Jiaxuan You

Generates query-specific workflows by selecting both language-model backbones and agent roles while consulting a heterogeneous graph of query-agent-response history.

Combines work-graph routing with reusable interaction memory and evaluates unseen-task and unseen-model generalization rather than only in-distribution quality.


Stop Wasting Your Tokens: Towards Efficient Runtime Multi-Agent Systems

Fulin Lin; Shaowen Chen; Ruishan Fang; Hongwei Wang; Tao Lin

Adds a lightweight supervisor triggered by an LLM-free filter to intervene when a multi-agent run shows errors, inefficient behavior, or contaminated observations.

Places cost and failure control inside the live execution path and tests whether selective supervision can reduce token use without redesigning the base graph.


Aegis: Automated Error Generation and Attribution for Multi-Agent Systems

Fanqi Kong; Ruijie Zhang; Huaxiao Yin; Guibin Zhang; Xiaofei Zhang; Ziang Chen; Zhaowei Zhang; Xiaoyuan Zhang; Song-Chun Zhu; Xue Feng

Creates 9,533 trajectories with annotated faulty agents and error modes by injecting context-aware faults into successful runs across multiple architectures and domains.

Provides graph-component labels for training and evaluating failure attribution instead of relying only on final-task success or expensive manual trace review.


MARTI: A Framework for Multi-Agent LLM Systems Reinforced Training and Inference

Kaiyan Zhang; Kai Tian; Runze Liu; Sihang Zeng; Xuekai Zhu; Guoli Jia; Yuchen Fan; Xingtai Lv; Yuxin Zuo; Che Jiang; Yuru Wang; Jianyu Wang; Ermo Hua; Xinwei Long; Junqi Gao; Youbang Sun; Zhiyuan Ma; Ganqu Cui; Ning Ding; Biqing Qi; Bowen Zhou

Supports centralized multi-agent interaction, distributed policy training, asynchronous rollouts, graph-defined workflows, heterogeneous models, tools, and configurable rewards.

Connects executable organizations to reinforced training infrastructure so graph policies can be optimized and evaluated rather than remaining hand-authored inference code.


MPAS: Breaking Sequential Constraints of Multi-Agent Communication Topologies via Individual-Epistemic Message Propagation

Jingxuan Yu; Ju Jia; Simeng Qin; Xiaojun Jia; Siqi Ma; Yihao Huang; Yali Yuan; Guang Cheng

Reworks sequential multi-agent communication into parallel graph message propagation with optimized connections and aggregation while preserving agent-specific epistemic state.

Targets latency introduced by dependency-ordered exchanges and makes the tradeoff between parallel execution, aggregation, and resilience measurable.


AgentRx: Diagnosing AI Agent Failures from Execution Trajectories

Shraddha Barke; Arnav Goyal; Alind Khare; Avaljot Singh; Suman Nath; Chetan Bansal

Releases 115 manually annotated failed trajectories and diagnoses critical failure steps by synthesizing guarded executable constraints and evidence-bearing validation logs.

Provides a concrete bridge from heterogeneous agent traces to repeatable failure localization; its evaluation includes Magentic-One but also single-agent workflows.


MAESTRO: Multi-Agent Evaluation Suite for Testing, Reliability, and Observability

Tie Ma; Yixi Chen; Vaastav Anand; Alessandro Cornacchia; Amândio R. Faustino; Guanheng Liu; Shan Zhang; Hongbin Luo; Suhaib A. Fahmy; Zafar A. Qazi; Marco Canini

Standardizes configuration and execution for 12 representative multi-agent systems and exports framework-agnostic traces with latency, cost, reliability, and failure signals.

Enables controlled comparison across architectures and repeated runs while revealing that topology can dominate model or tool changes in resource and reliability profiles.


AgentTrace: Causal Graph Tracing for Root Cause Analysis in Deployed Multi-Agent Systems

arXiv; ICLR 2026 Workshop on Agents in the Wild

Reconstructs causal graphs from execution logs, traces backward from observed failures, and ranks candidate root causes without requiring language-model inference during debugging.

Offers an interpretable, low-latency diagnosis primitive for cascading failures while remaining a preprint and workshop result rather than broad production validation.


Multi-Agent Reference Architecture

Maps agent registries, communication, memory, observability, evaluation, security, governance, and deployment into an end-to-end reference architecture for multi-agent systems.

Provides a broad engineering checklist grounded in customer implementations; it is evolving guidance in an official repository, not a versioned standard.


AutoGen Core

Documents an actor-style agent runtime with asynchronous messages, topics, subscriptions, distributed execution, resilience mechanisms, and telemetry.

Adds the lower-level message and runtime architecture beneath conversational teams, clarifying how agent nodes communicate and scale across processes.


Multiagent orchestration

Documents managed multi-agent orchestration with a lead agent that creates specialized subagents, delegates work, and combines their results under a beta API contract.

Provides a current first-party implementation of dynamic specialization and hierarchical delegation while clearly exposing its managed-runtime boundary and beta status.


Introducing Agent Executor, Google’s distributed Agent Runtime

Introduces an open-source runtime standard for execution, resumption, isolation, session consistency, reconnection, trajectory branching, and federated agent deployment.

Addresses durable long-running graphs at the runtime layer and makes checkpoints, single-writer state, recovery, and deployment boundaries explicit; the release is in preview.


NVIDIA NeMo Agent Toolkit

Provides framework-agnostic profiling, evaluation, optimization, tracing, and A2A team support for agent workflows, including experimental graph-performance primitives.

Lets engineers measure whole-graph latency and cost while experimenting with parallel branches, speculative execution, and node priorities in maintained open-source tooling.


A2A Protocol Technology Compatibility Kit

Tests Agent2Agent protocol implementations across gRPC, JSON-RPC, and HTTP with JSON and emits machine-readable, HTML, and JUnit conformance reports.

Turns interoperability claims at agent handoff edges into executable gates that can run in development and continuous integration.


AGNTCY Dir

Implements a distributed directory for capability-based discovery of agents and multi-agent systems using OASF records and cryptographic identity.

Covers how potential graph participants are registered, discovered, authenticated, and selected before a work or communication edge is created.


Agent Governance Toolkit

Enforces runtime policies on tool calls and inter-agent messages with identity, delegation, audit logs, telemetry, and adapters for multiple agent frameworks.

Implements authorization and audit controls at graph edges; it is a public preview, and its in-process enforcement layer is not an operating-system security boundary.


Multi-Agentic System Threat Modeling Guide v1.0

Applies an agentic threat taxonomy to multi-agent architectures and examines attack surfaces introduced by delegation, messaging, shared memory, tools, and cross-agent actions.

Provides a structured way to identify graph-specific trust boundaries and abuse paths; it is community security guidance rather than a certification or formal standard.


AgentOps: Operationalize agentic AI at scale with Amazon Bedrock AgentCore

Anastasia Tzeveleka; Anna Grüebler; Antonio Rodriguez; Sergio Garcés Vitale; Aris Tsakpinis

Organizes production agent operations around governance, build and release, multi-level evaluation, observability, identity propagation, and cost attribution in a reference architecture.

Adds concrete system measures such as orchestration accuracy and exchange quality while keeping the vendor-specific implementation context visible.


Powering agentic AI sales strategy with Amazon Bedrock AgentCore

Nicolle Belaunde; Umesh Mohan; Xinrui Nie

Describes an internal production system with more than 20 domain agents, supervisor routing, OAuth propagation, MCP tools, approvals, memory, distributed tracing, and evaluation.

Offers a rare detailed account of an enterprise supervisor graph at operating scale; its usage, latency, and outcome figures are self-reported by AWS.


Designing Autonomous AI Agents: How We Built a Multi-Agent Swarm for UI Development

Stanislau Shandrokha; Pavel Golub; Andrey Voroshkov

Describes a seven-agent state-machine workflow with resumable state, explicit roles, adversarial visual and code reviewers, and verification gates for interface development.

Reports practical failures such as overlapping work, skipped steps, and rubber-stamping alongside mitigations; the evidence is a narrow, self-reported implementation account.


FIPA ACL Message Structure Specification

Foundation for Intelligent Physical Agents

FIPA TC Communication; FIPA Architecture Board

Defines interoperable agent messages with performatives, sender and receiver, ontology, protocol, conversation identifiers, reply correlation, and deadlines.

Supplies the historical standards basis for message-envelope and conversation concepts that reappear in current agent handoff protocols.


Red-teaming a network of agents: Understanding what breaks when AI agents interact at scale

Gagan Bansal; Shujaat Mirza; Keegan Hines; Will Epperson; Zachary Huang; Whitney Maxwell; Pete Bryan; Tyler Payne; Adam Fourney; Amanda Swearngin; Wenyue Hua; Tori Westerhoff; Amanda Minnich; Maya Murad; Ece Kamar; Ram Shankar Siva Kumar; Saleema Amershi

Reports a red-team exercise on a live internal platform with more than 100 persistent agents and identifies propagation, amplification, trust capture, and invisibility failures.

Demonstrates interaction risks that do not appear in isolated-agent tests; the environment and findings are company-reported rather than independently reproduced.


HyperAgent: Leveraging Hypergraphs for Topology Optimization in Multi-Agent Communication

Heng Zhang; Yuling Shi; Xiaodong Gu; Zijian Zhang; Haochen You; Lubin Gan; Yilei Yuan; Jin Huang

Represents collaboration groups as hyperedges and uses a variational hypergraph autoencoder with sparsity regularization to generate task-adaptive communication topology.

Adds group-level topology learning beyond pairwise edges and differs from evolving-hypergraph work by focusing on generated sparse structures for each task.


D³MAS: Decompose, Deduce, and Distribute for Enhanced Knowledge Sharing in Multi-Agent Systems

Heng Zhang; Yuling Shi; Xiaodong Gu; Haochen You; Zijian Zhang; Lubin Gan; Yilei Yuan; Jin Huang

Connects task decomposition, collaborative reasoning, and distributed memory as coordinated layers in a heterogeneous graph designed to reduce duplicated retrieval, inference, and assignment.

Unifies work, reasoning, and state dependencies in one inspectable organization rather than optimizing those coordination surfaces separately.


µACP: A Formal Calculus for Expressive, Resource-Constrained Agent Communication

Formalizes resource-bounded agent communication with PING, TELL, ASK, and OBSERVE operations, proves finite-state expressiveness and message bounds, and checks properties with TLA+ and Coq.

Provides a precise substrate for reasoning about protocol behavior and communication budgets; it is a general multi-agent calculus rather than an LLM-specific runtime.


Multi-Agent Collaboration via Evolving Orchestration

Yufan Dang; Chen Qian; Xueheng Luo; Jingru Fan; Zihao Xie; Ruijie Shi; Weize Chen; Cheng Yang; Xiaoyin Che; Ye Tian; Xuantang Xiong; Lei Han; Zhiyuan Liu; Maosong Sun

Trains a centralized orchestrator with reinforcement learning to select and sequence agents from evolving task state, producing dynamic inference graphs and compact cyclic reasoning paths.

Learns runtime activation and ordering rather than fixing a workflow in advance, providing a centralized contrast to decentralized evolutionary coordination.