Internet of Agents: Weaving a Web of Heterogeneous Agents for Collaborative Intelligence

## Abstract

Abstract The rapid advancement of large language models (LLMs) has paved the way for the development of highly capable autonomous agents. However, existing multi-agent frameworks often struggle with integrating diverse capable third-party agents due to reliance on agents defined within their own ecosystems. They also face challenges in simulating distributed environments, as most frameworks are limited to single-device setups. Furthermore, these frameworks often rely on hard-coded communication pipelines, limiting their adaptability to dynamic task requirements. Inspired by the concept of the Internet, we propose the Internet of Agents (IoA), a novel framework that addresses these limitations by providing a flexible and scalable platform for LLM-based multi-agent collaboration. IoA introduces an agent integration protocol, an instant-messaging-like architecture design, and dynamic mechanisms for agent teaming and conversation flow control. Through extensive experiments on general assistant tasks, embodied AI tasks, and retrieval-augmented generation benchmarks, we demonstrate that IoA consistently outperforms state-of-the-art baselines, showcasing its ability to facilitate effective collaboration among heterogeneous agents. IoA represents a step towards linking diverse agents in an Internet-like environment, where agents can seamlessly collaborate to achieve greater intelligence and capabilities. Our codebase has been released at https://github.com/OpenBMB/IoA .

## 1 Introduction

The Internet has revolutionized the way people collaborate and share knowledge, connecting individuals with diverse skills and backgrounds from all around the world. This global network has enabled the creation of remarkable collaborative projects, such as Wikipedia(^1^11[https://www.wikipedia.org/](https://www.wikipedia.org/)) and the development of the Linux operating system(^2^22[https://www.linux.org/](https://www.linux.org/)), which would have been impossible for any single person to achieve. The Internet has greatly facilitated collaboration among people, making the impossible possible and pushing the boundaries of human achievement.

The success of the Internet in enabling human collaboration raises an intriguing question: can we create a similar platform to facilitate collaboration among autonomous agents? With the rapid advancements in LLMs (OpenAI, ; Reid et al., ), we now have autonomous agents capable of achieving near-human performance on a wide range of tasks. These LLM-based agents have demonstrated the ability to break down complex tasks into executable steps, leverage various tools, and learn from feedback and experience (Qin et al., ; Wang et al., ; Shinn et al., ; Qian et al., ). As the capabilities of these agents continue to grow, and with an increasing number of third-party agents with diverse skills consistently emerging (Chase, ; Team, ; Significant Gravitas, ; Open Interpreter, ), it is crucial to explore how we can effectively and efficiently orchestrate their collaboration, just as the Internet has done for humans.

To address this challenge, we propose the concept of the Internet of Agents (IoA), a general framework for agent communication and collaboration inspired by the Internet. IoA aims to address three fundamental limitations of existing multi-agent frameworks (Chen et al., ; Wu et al., ; Hong et al., ; Qian et al., ): (1) Ecosystem Isolation: Most frameworks only consider agents defined within their own ecosystems, potentially blocking the integration of various third-party agents and limiting the diversity of agent capabilities and the platform’s generality; (2) Single-Device Simulation: Nearly all multi-agent frameworks simulate multi-agent systems on a single device, which differs significantly from real-world scenarios where agents could be distributed across multiple devices located in different places; (3) Rigid Communication and Coordination: The communication process, agent grouping, and state transitions are mostly hard-coded, whereas in real life, humans decide on teammates based on the task at hand and dynamically switch between discussion and task assignment or execution.

To overcome these limitations, we propose an agent integration protocol that enables different third-party agents running on different devices to be seamlessly integrated into the framework and collaborate effectively. Additionally, we introduce an instant-messaging-app-like framework that facilitates agent discovery and dynamic teaming. By autonomously searching for potential agents capable of handling the tasks at hand, agents can dynamically decide to form different teams and communicate within various group chats. Inspired by Speech Act Theory (Searle, ), and its application in conventional multi-agent system (Finin et al., ; Labrou et al., ), within each group chat, we abstract out several conversation states and provide a flexible and general finite-state machine mechanism that allows agents to autonomously decide the state of the conversation, facilitating discussion and sub-task execution.

We demonstrate the effectiveness of IoA through extensive experiments and comparisons with state-of-the-art autonomous agents. By integrating AutoGPT (Significant Gravitas, ) and Open Interpreter (Open Interpreter, ), we show that IoA achieves a 66 to 76% win rate in open-domain task evaluations when compared with these agents individually. Furthermore, with only a few basic ReAct agents integrated, IoA outperforms previous works on the GAIA benchmark (Mialon et al., ). In the retrieval-augmented generation (RAG) question-answering domain, our framework substantially surpasses existing methods, with a GPT-3.5-based implementation achieving performance close to or even exceeding GPT-4, and effectively surpassing previous multi-agent framework.

The impressive performance of IoA across various domains highlights the potential of this paradigm for autonomous agents. As smaller LLMs continue to advance (Mesnard et al., ; Hu et al., ; Abdin et al., ), running agents on personal computer or even mobile device is becoming increasingly feasible. This trend opens up new opportunities for deploying multi-agent systems in real-world scenarios, where agents can be distributed across multiple devices and collaborate to solve complex problems. We believe that by further exploring and refining the IoA paradigm, more sophisticated and adaptable multi-agent systems can be developed, ultimately pushing the boundaries of what autonomous agents can achieve in problem-solving and decision-making.

## 2 Framework Design and Key Mechanisms of IoA

In this section, we present a comprehensive overview of IoA, detailing its architecture and key mechanisms. We will explore how these components work together to enable effective collaboration among autonomous agents, facilitating dynamic team formation, structured communication, and efficient task execution.

### 2.1 Overview of IoA

IoA is designed as an instant-messaging-app-like platform that enables seamless communication and collaboration among diverse autonomous agents. Inspired by the concept of Internet, IoA addresses three fundamental challenges in multi-agent systems (Chen et al., ; Wu et al., ; Qian et al., ):

- 1.
Distributed agent collaboration: Unlike traditional frameworks that simulate multi-agent systems on a single device, IoA supports agents distributed across multiple devices and locations. (Sections 2.2 and 2.3.1)
- 2.
Dynamic and adaptive communication: IoA implements mechanisms for autonomous team formation and conversation flow control, allowing agents to adapt their collaboration strategies based on task requirements and ongoing progress. (Sections 2.3.2, 2.3.3 and 2.3.4)
- 3.
Integration of heterogeneous agents: IoA provides a flexible protocol for integrating various third-party agents, expanding the diversity of agent capabilities within the system. (Section 2.4)

At its core, IoA consists of two main components: the server and the client. The server acts as a central hub, managing agent registration, discovery, and message routing. It enables agents with varying capabilities to find each other and initiate communication. The client, on the other hand, serves as a wrapper for individual agents, providing them with the necessary communication functionalities and adapting them to the specified protocol.
IoA employs a layered architecture (Bass et al., ) for both the server and client components, comprising three layers:

- •
Interaction Layer: Facilitates team formation and agent communication.
- •
Data Layer: Manages information related to agents, group chats, and tasks.
- •
Foundation Layer: Provides essential infrastructure for agent integration, data management, and network communication.

These layers work together to facilitate agent collaboration through the network. In the following subsections, we will go through the IoA’s architecture and design.

Figure: Figure 1: The illustration on the conceptual layered architecture on the design of IoA.
Refer to caption: x1.png

### 2.2 Architecture of IoA

The layered architecture of IoA is designed to support scalable, flexible, and efficient multi-agent collaboration. This architecture enables a clear separation of concerns and facilitates the integration of diverse agents and functionalities (Fig. 1).

#### 2.2.1 Server Architecture

The server acts as the central hub of IoA, facilitating agent discovery, group formation, and message routing. Its architecture consists of three layers:

Interaction Layer: At the top level, the Interaction Layer manages high-level interactions between agents and the system. It encompasses the Agent Query Block for enabling agents to search for other agents based on specific characteristics, the Group Setup Block for facilitating the creation and management of group chats, and the Message Routing Block for ensuring efficient and accurate routing of messages between agents and group chats.

Data Layer: Serving as the information backbone, the Data Layer handles the storage and management of critical system information. The Agent Registry Block maintains a comprehensive database of registered agents, including their capabilities and current status, similar to service discovery in distributed systems (Meshkova et al., ; ). Meanwhile, the Session Management Block manages active connections and ensures continuous communication between the server and connected clients.

Foundation Layer: Underpinning the entire system, the Foundation Layer provides the essential infrastructure for the server’s operations. It encompasses the Data Infrastructure Block for handling data persistence and retrieval, the Network Infrastructure Block for managing network communications, and the Security Block for implementing authentication, authorization, and other security measures to maintain system integrity.

#### 2.2.2 Client Architecture

The client component of IoA serves as a wrapper for individual agents, providing them with the necessary interfaces to communicate within the system. Its architecture mirrors that of the server with three layers:

Interaction Layer: At the forefront of agent operations, the Interaction Layer manages the agent’s interactions within the system. The Team Formation Block implements the logic for identifying suitable collaborators and forming teams for the task at hand, similar to coalition formation in conventional multi-agent research (Rahwan et al., ). Complementing this, the Communication Block manages the agent’s participation in group chats and handles message processing.

Data Layer: Functioning as the agent’s memory, the Data Layer maintains local data relevant to the agent’s operations. It includes the Agent Contact Block for storing information about other agents the current agent has interacted with, the Group Info Block for maintaining details about ongoing group chats and collaborations, and the Task Management Block for tracking the status and progress of tasks assigned to the agent.

Foundation Layer: Forming the base of the client architecture, the Foundation Layer provides the basic functionalities for the client’s operations. The Agent Integration Block defines the protocols and interfaces for integrating third-party agents into the IoA ecosystem. Alongside this, the Data Infrastructure Block handles local data storage and retrieval, while the Network Infrastructure Block manages network communications with the server.

This layered architecture enables IoA to support a wide range of agent types and collaboration scenarios. By providing a clear separation of concerns and well-defined interfaces between layers, the architecture facilitates the integration of diverse agents and allows for future extensibility. Furthermore, this design supports the key mechanisms of IoA, such as autonomous team formation and conversation flow control, which we will explore in detail in the following subsections.

### 2.3 Key Mechanisms

The effectiveness of IoA relies on several key mechanisms that enable seamless collaboration among diverse agents. These mechanisms work in concert to facilitate agent integration, team formation, task allocation, and structured communication. We detail these critical components in this section.

#### 2.3.1 Agent Registration and Discovery

To enable collaboration among distributed agents with heterogeneous architectures, tools, and environments, we propose the agent registration and discovery mechanism. This mechanism forms the foundation for collaborative interactions within IoA, enabling the integration of diverse agents into the system and facilitating their discovery on the online server by other agents for potential collaboration through the network.

Agent Registration: When a new agent joins the IoA, its client wrapper undergoes a registration process with the server. During registration, the agent should provide a comprehensive description of its capabilities, skills, and areas of expertise. This description, denoted as $d_{i}$ for an agent $c_{i}$, is stored in the Agent Registry Block of the server’s Data Layer. Formally, we represent the set of all registered agents as $\mathcal{C}=\{c_{1},c_{2},...,c_{n}\}$, where each $c_{i}$ is associated with its description $d_{i}$.

Agent Discovery: The agent discovery function leverages the information stored in the Agent Registry from the online server to enable agents to find suitable collaborators for specific tasks. When an agent needs to form a team or seek assistance, it can use the search_client tool provided by the server’s Agent Query Block. This tool allows an agent to search for other agents based on desired characteristics or capabilities. Formally, the agent discovery process can be described as follows: Let $\mathcal{L}_{d}=[l_{1},l_{2},...,l_{k}]$ be a list of desired characteristics generated by an agent seeking collaborators. The search_client function can be represented as:
$\texttt{search_client}:\mathcal{L}_{d}\rightarrow\mathcal{P}(\mathcal{C})$,
where $\mathcal{P}(\mathcal{C})$ denotes the power set of $\mathcal{C}$. The function returns a subset of clients $\mathcal{C}_{d}\subseteq\mathcal{C}$ whose descriptions $d_{j}$ match the desired characteristics in $\mathcal{L}_{d}$.
The matching process between $\mathcal{L}_{d}$ and $d_{j}$ can be implemented with various semantic matching techniques (Robertson & Zaragoza, ; Karpukhin et al., ). It ensures that agents with relevant capabilities can be discovered even if their descriptions do not exactly match the search criteria.

#### 2.3.2 Autonomous Nested Team Formation

The autonomous nested team formation mechanism enables dynamic and flexible combinations of appropriate agents. This mechanism allows agents to form teams adaptively based on task requirements and to create nested sub-teams for complex, multi-faceted tasks.

Team Formation Process: When a client $c_{i}\in\mathcal{C}$ is assigned a task $t$, it initiates the team formation process. The client has access to two essential tools provided by the server: search_client and launch_group_chat.
The LLM in the client is prompted to decide which tool to call based on the task and the current set of discovered clients. If more collaborators are needed, it calls search_client with appropriate characteristics. Once suitable collaborators are found, it calls launch_group_chat to initiate a new group chat $g\in\mathcal{G}$, where $\mathcal{G}$ is the space of all group chats.

Nested Team Structure: The nested team formation allows for a hierarchical structure of teams and sub-teams. Let $g_{0}\in\mathcal{G}$ be the initial group chat for task $t$. During the execution of $t$, if a client $c_{i}$ is assigned with a sub-task $t_{l}$ (the task assignment mechanism will be introduced in Section 2.3.4), and it identifies $t_{l}$ requires additional expertise, $c_{i}$ is allowed to search for appropriate agents again and initiate a new sub-group chat $g_{l}\in\mathcal{G}$. This process can continue recursively for the new sub-tasks assigned in $g_{l}$, forming a tree-like structure of group chats.
Formally, we can define a function $h:\mathcal{G}\rightarrow\mathcal{P}(\mathcal{G})$ that maps a group chat to its set of sub-group chats. The nested structure can be represented as:
$h(g_{0})=\{g_{1},g_{2},...,g_{m}\},\quad h(g_{i})=\{g_{i1},g_{i2},...,g_{in}\}$, and so on.

Figure: Figure 2: An example of nested team formation mechanism. The process is simplified for clarity.
Refer to caption: x2.png

Communication Complexity: The nested team formation mechanism helps reduce communication complexity in large agent teams. Assuming fully connected communication within each group, the number of communication channels (connected edges) in a single group with $|g|$ members is $c_{\text{full}}=\frac{|g|(|g|-1)}{2}$. However, by decomposing a task into sub-tasks and allocating them to sub-group chats, we can reduce the total number of communication channels.
Let $\mathcal{S}(g)$ denote the set of all sub-groups (including $g$ itself) formed for a task initially assigned to group $g$. The total number of communication channels can then be expressed as:
$c_{\text{nested}}=\sum_{g_{i}\in\mathcal{S}(g)}\frac{|g_{i}|(|g_{i}|-1)}{2}
\leq c_{\text{full}}$.

Fig. 2 illustrates an example of the nested team formation process. In this example, the initial group chat $g_{0}$ spawns three sub-group chats $g_{1}$, $g_{2}$ and $g_{3}$ for specific sub-tasks during the discussion. $g_{1}$ further creates two sub-group chats $g_{21}$ and $g_{22}$ for a more specialized sub-task.

#### 2.3.3 Autonomous Conversation Flow Control

Effective communication is crucial for successful collaboration among autonomous agents. Inspired by Speech Act Theory (Austin, ; Searle, ) and its applications in multi-agent systems (Finin et al., ; Labrou et al., ), we introduce an autonomous conversation flow control mechanism in IoA. This mechanism enables agents to coordinate their communication and maintain a structured dialogue, enhancing the efficiency and effectiveness of their collaboration.

Sequential Speaking Mechanism: To manage potential conflicts and ensure clear communication, IoA adopts the most basic sequential speaking mechanism. At any given time, only one agent is permitted to speak, preventing confusion and maintaining a clear order of communication. This approach, while simple, provides a foundation for more sophisticated conversation management when combined with the following dynamic features.

Finite State Machine for Group Chat States: We formalize the conversation flow as a finite state machine $M=(S,\Sigma,\delta,s_{0},F)$, where:

- •
$S=\{s_{d},s_{s},s_{a},s_{p},s_{c}\}$ is the set of states representing discussion, synchronous task assignment, asynchronous task assignment, pause & trigger, and conclusion, respectively.
- •
$\Sigma$ is the state transition decision space.
- •
$\delta:S\times\Sigma\to S$ is the transition function mapping the current state and the transition decision made by LLMs to the next state.
- •
$s_{0}=s_{d}$ is the initial state, representing the start of the conversation in the discussion phase.
- •
$F=\{s_{c}\}$ is the set of final states, containing only the conclusion state.

Figure 3 illustrates the state transitions in the conversation flow. Each state corresponds to different phases of the collaboration process:

- •
Discussion ($s_{d}$): Agents engage in general dialogue, exchange ideas, and clarify task requirements.
- •
Synchronous task assignment ($s_{s}$): Tasks are assigned to specific agents, pausing the group chat until completion (Section 2.3.4).
- •
Asynchronous task assignment ($s_{a}$): Tasks are assigned without interrupting the ongoing discussion (Section 2.3.4).
- •
Pause & trigger ($s_{p}$): The group chat is paused, waiting for the completion of specified asynchronous tasks.
- •
Conclusion ($s_{c}$): Marks the end of the collaboration, prompting a final summary.

Figure: Figure 3: The state transition among different states.
Refer to caption: x3.png

These states align with speech acts in Speech Act Theory, such as assertives (discussion), directives (task assignment), commissives (pause & trigger), and declarations (conclusion) (Searle, ).

Autonomous State Transitions and Next Speaker Selection: Recent studies have demonstrated the efficacy of LLMs in autonomously managing state transitions within predefined state spaces (Liu & Shuai, ; Wu et al., ), with state machines often enhancing overall system performance (Li et al., ). In IoA, the LLM within each client is tasked with determining state transitions and selecting the subsequent speaker. Let $\mathcal{M}_{t}$ be the set of messages exchanged up to time step $t$. We define the decision function of the LLM as:
$f_{\text{LLM}}:\mathcal{M}_{t}\times S\to S\times\mathcal{C}$,
where $S$ is the set of states and $\mathcal{C}$ is the set of clients. The next state $s_{t+1}$ and the next speaker $c_{t+1}$ are determined as:
$(s_{t+1},c_{t+1})=f_{\text{LLM}}(\mathcal{M}_{t},s_{t})$.
This decision-making process considers factors such as the completion of assigned tasks, the need for further discussion, and the overall goals of the collaboration. The autonomous selection of the next speaker ensures that the most relevant agents are involved at appropriate times, promoting efficient information exchange and problem-solving.

By implementing this autonomous conversation flow control mechanism, IoA enables structured and efficient communication among agents. This approach allows for dynamic adaptation to the needs of the collaboration, facilitating more effective problem-solving and decision-making in complex multi-agent scenarios.

#### 2.3.4 Task Assignment and Execution

The task assignment and execution mechanism in IoA is designed to efficiently distribute work among agents and manage the execution of both simple and complex tasks. This mechanism works in concert with the team formation and conversation flow control mechanisms to ensure effective collaboration and task completion.

Task Representation: In IoA, a task $t\in\mathcal{T}$ is represented as a tuple $(d_{t},\mathcal{S}_{t})$, where $d_{t}$ is the task description and $\mathcal{S}_{t}=\{s_{1},s_{2},...,s_{n}\}$ is the set of sub-tasks that $t$ can be decomposed into. Initially, $\mathcal{S}_{t}$ may be empty, with sub-tasks being identified dynamically during the collaboration process.

Task Allocation: Task allocation in IoA occurs within the context of group chats and is closely tied to the conversation flow control mechanism. There are two types of task allocation:

- 1.
Synchronous Task Allocation: When the group chat enters the synchronous task assignment state $s_{s}$, tasks are allocated to specific agents, and the group chat is paused until the tasks are completed.
- 2.
Asynchronous Task Allocation: In the asynchronous task assignment state $s_{a}$, tasks are allocated without interrupting the ongoing discussion. This allows for parallel execution of tasks.

Formally, we can define a task allocation function $\alpha:\mathcal{T}\times\mathcal{G}\rightarrow\mathcal{P}(\mathcal{C})$, which maps a task and a group chat to a subset of clients responsible for executing the task.

Task Execution: Once a task is allocated, the responsible agent(s) begin execution. The execution process depends on the nature of the task and the capabilities of the agent. For integrated third-party agents, task execution is handled through the Agent Integration Block in the client’s Foundation Layer. This block provides a standardized interface for task execution, typically in the form:
$\texttt{run}:\text{String}\rightarrow\text{TaskID}$,
where the input is the task description, and the output is a unique identifier for the task. Advanced features such as execution interruption could also be implemented in this stage.

Upon completion of a task or sub-task, the responsible agent(s) report back to the group chat. In the case of synchronous tasks, this triggers the resumption of the group chat. For asynchronous tasks, the completion is noted, and any relevant information is shared with the group.

The pause & trigger state $s_{p}$ in the conversation flow control mechanism plays a crucial role in managing the completion of multiple asynchronous tasks. It allows the group chat to wait for the completion of specified asynchronous tasks before proceeding, ensuring that all necessary information is available for subsequent stages of the collaboration.

### 2.4 Comprehensive Message Protocol Design

The effectiveness of the autonomous nested team formation and conversation flow control mechanisms in IoA relies on a comprehensive message protocol. This protocol enables seamless communication and collaboration among agents by encapsulating all necessary information required for various mechanisms to function properly.

##### Protocol Overview and Key Fields

The agent message protocol in IoA is designed for extensibility and flexibility, facilitating effective multi-agent collaboration. The protocol consists of two main components: a header and a payload.

The header contains essential metadata about the message, ensuring correct addressing and processing by receiving agents. Key fields in the header include:

- •
sender: The unique identifier of the agent sending the message.
- •
group_id: The identifier of the group chat to which the message belongs.

The payload carries the main content of the message, varying by message type. It can include:

- •
message_type: Indicates the purpose of the message (e.g., discussion, task assignment, pause & trigger).
- •
next_speaker: The identifier(s) of the agent(s) expected to respond.

This structure contains other fields to support the diverse functionalities of IoA effectively. A detailed explanation and example of the message protocol can be found in Section A.1.

To ensure seamless communication and coordination, both the client and server components of IoA implement the message protocol. When a client sends a message, it encodes it according to the protocol and transmits it to the server. The server parses the message, extracts relevant information from the header, and routes it to the appropriate group chat based on the group_id. Upon receiving a message, the client decodes it and processes it accordingly. This consistent implementation ensures that all agents can understand and respond to messages correctly, regardless of their roles or tasks, maintaining a coherent and efficient collaboration process.

### 2.5 Putting It All Together: A Walkthrough of IoA in Action

Figure: Figure 4: An example walkthrough of the major components of IoA.
Refer to caption: x4.png

To illustrate the integrated functionality of IoA, in Fig. 4, we present an example walkthrough of the system with an illustrative complex task: writing a research paper on the Internet of Agents. Initially, client $c_{1}$, an AI research specialist trained additionally on AI academic paper, engages the Team Formation Block, utilizing the search_client function with
a list of keywords {Internet, Multi-Agent System Specialist, Paper Writing, LLM Expert}. The server returns a set of matched clients $\{c_{2},c_{3},c_{4},c_{5}\}$, from which $c_{1}$ forms group $g_{0}$ with members $\{c_{1},c_{2},c_{3}\}$ via launch_group_chat, where $c_{2}$ has access to scholarly databases and $c_{3}$ specializes in academic writing.

Upon the formation of group chat $g_{0}$, all clients transition to the Communication Block for $g_{0}$, where the autonomous conversation flow control mechanism, implemented as a finite state machine, guides the collaboration. The process begins with brainstorming in the discussion state ($s_{d}$), progressing to task assignment states ($s_{s},s_{a}$) where agents are allocated specific responsibilities. For instance, $c_{2}$ is tasked with conducting a literature review using its access to scholarly resources. The nested team formation mechanism is demonstrated when $c_{2}$ identifies a need for specialized PDF expertise. This prompts $c_{2}$ to initiate a sub-group formation process, resulting in the creation of sub-group $g_{1}$ with a new agent $c_{6}$, a PDF expert. Throughout the process, the conversation alternates between discussion ($s_{d}$) and asynchronous task assignment ($s_{a}$) states, facilitating parallel work on assigned tasks. The message protocol ensures efficient communication, enabling the exchange of ideas, citations, and draft segments across the nested group structure.

In the final integration phase, the group enters a synchronous task assignment state ($s_{s}$) for collaborative editing and refinement, demonstrating IoA’s capacity for coordinating intensive, real-time collaboration among multiple agents. The process concludes with a transition to the conclusion state ($s_{c}$), where a final review is conducted and the paper is prepared for submission.

## 3 Experiments

To demonstrate the effectiveness and versatility of IoA in integrating heterogeneous agents, we conduct comprehensive experiments across a diverse set of tasks. These experiments are designed to showcase different aspects of agent heterogeneity: tool variability (Section 3.1), architectural diversity (Section 3.2), disparate observation and action spaces (Section 3.3), and varied knowledge bases (Section 3.4). Our objective is twofold: first, to illustrate IoA’s proficiency in facilitating collaboration among heterogeneous agents, and second, to highlight its adaptability across various problem domains. In this section, we present our experimental results and offer comparative analyses between IoA and state-of-the-art (SoTA) approaches for each task category. The prompts within IoA are kept the same across different tasks, and are not specifically tuned for a certain task.(^3^33If not specified, we use GPT-4-1106-preview model in our experiments.)

**Table 1: The performance on the validation set of GAIA benchmark.**
| Models | Agent Type | Level 1 | Level 2 | Level 3 | Overall |
| --- | --- | --- | --- | --- | --- |
| GPT-4 | \faUser | 15.09 | 2.33 | 0.00 | 6.06 |
| GPT-4-Turbo | \faUser | 20.75 | 5.81 | 0.00 | 9.70 |
| AutoGPT-4 (Significant Gravitas, ) | \faUser | 13.21 | 0.00 | 3.85 | 4.85 |
| GPT-4 + Plugins (Mialon et al., ) | \faUser | 30.30 | 9.70 | 0.00 | 14.60 |
| FRIDAY (Wu et al., ) | \faUser | 45.28 | 34.88 | 11.54 | 34.55 |
| AutoGen (Wu et al., ) | \faUsers | 54.72 | 38.37 | 11.54 | 39.39 |
| IoA | \faUsers | 50.94 | 40.70 | 15.38 | 40.00 |

### 3.1 Heterogeneous Tools: GAIA Benchmark

To evaluate IoA’s capability in integrating agents with heterogeneous tools, we employ the GAIA benchmark (Mialon et al., ). This benchmark comprises a diverse set of real-world questions designed to assess an agent system’s proficiency in solving complex tasks through the synergistic application of multiple skills, including natural language understanding, reasoning, and external knowledge integration. The benchmark’s three-tiered difficulty structure provides a robust testbed for evaluating the capability of agent systems.

Experimental Setups:
We instantiate IoA with four basic ReAct agents (Yao et al., ), each equipped with a distinct tool: a web browser, a code interpreter, a Wikidata searcher, and a YouTube video transcript downloader. This configuration allows us to assess IoA’s ability to orchestrate collaboration among agents with heterogeneous tools. We benchmark IoA against several SoTA agent systems, evaluating performance across all three difficulty levels of GAIA, as well as overall performance. Detailed implementation specifics are provided in Section A.4.1.

Results and Analysis:
The experimental results, presented in Table 1, demonstrate IoA’s superior performance across the GAIA benchmark. Despite utilizing only basic ReAct agents, IoA achieves the highest overall performance, surpassing all other approaches. Notably, IoA exhibits exceptional performance in the more challenging Level 2 and Level 3 tasks, which demand advanced reasoning and intricate collaboration. This performance underscores the efficacy of IoA’s communication mechanisms and its capacity to facilitate seamless inter-agent collaboration.

In comparison to AutoGen, IoA demonstrates superior performance in two out of three difficulty levels. This superiority can be attributed to IoA’s collaboration mechanisms and the flexibility of integrating agents with different tools, while in AutoGen, only one agent utilizes different tools, and other agents act as feedback providers. The mechanisms implemented in IoA enable adaptive team composition and efficient sub-task execution, culminating in enhanced performance on complex, multi-faceted problems.

The results from the GAIA benchmark underscore IoA’s potential as a powerful orchestrator for diverse agents in solving real-world, multi-step problems. By providing a flexible and efficient platform for agent collaboration, IoA enables even basic agents to achieve SoTA performance, outperforming more sophisticated standalone agents. This outcome highlights the critical role of effective communication and coordination in multi-agent systems and validates the architectural and design choices underpinning IoA.

### 3.2 Heterogeneous Architecture: Open-Ended Instruction Benchmark

Figure: Figure 5: Comparison of win rates on the open-ended instruction benchmark between IoA, AutoGPT, and Open Interpreter.
Refer to caption: x5.png

To evaluate IoA’s capability in integrating and orchestrating agents with heterogeneous architectures, we develop a comprehensive benchmark comprising 153 open-ended instructions with self-instruct (Wang et al., ). This benchmark spans four diverse categories: search & report, coding, mathematics, and life assistance. Unlike the GAIA benchmark, which primarily focuses on question-answering tasks with deterministic answers, our curated benchmark incorporates a higher proportion of non-QA tasks requiring generative responses. This design choice aims to better reflect the diverse nature of real-world challenges that agent systems are expected to address. The curation process is elaborated at Section A.4.2.

Experimental Setups:
In this experimental setup, we integrate two SoTA third-party agents with distinct architectures: AutoGPT (Significant Gravitas, ) and Open Interpreter (Open Interpreter, ), into the IoA ecosystem. The integration process, detailed in Section A.4.2, demonstrates IoA’s versatility in accommodating agents with divergent internal structures and operational paradigms. This configuration allows us to assess IoA’s efficacy in facilitating collaboration among independently developed agents with heterogeneous architectures.

For evaluation, we employ GPT-4-1106-preview as an impartial judge, a choice supported by previous research demonstrating high agreement between GPT models and human evaluators in assessing response quality (Chiang et al., ; Zheng et al., ; Chan et al., ). To mitigate potential order-induced biases, we implement a robust evaluation approach following Zheng et al. (), where the order of responses is alternated in the prompt. A ”win” is only declared when one competitor is consistently judged superior across both orderings.

Results and Analysis:
The experimental results, illustrated in Fig. 5, demonstrate IoA’s significant performance advantages when orchestrating the collaboration between AutoGPT and Open Interpreter. IoA consistently outperforms both individual agents across all four task categories. Overall, IoA achieves a remarkable win rate of 76.5% against AutoGPT and 63.4% against Open Interpreter. These results underscore IoA’s proficiency in efficiently gathering and synthesizing information, as well as its effectiveness in facilitating collaborative problem-solving across diverse domains.

The demonstrated capability of IoA to seamlessly integrate and orchestrate agents with heterogeneous architectures enables the harness of the strengths of diverse, independently developed agents, making it possible to create more versatile and capable agent systems. As the landscape of specialized AI agents continues to expand, IoA’s potential to integrate and facilitate collaboration among these diverse entities positions it as a promising platform for the development of increasingly sophisticated and adaptive agent systems.

### 3.3 Heterogeneous Observation and Action Space: Embodied Agent Tasks

**Table 2: Average success rate and the number of steps on different tasks from RoCoBench.**
| Model | Metric | Cabinet | Sweep | Sandwich | Sort | Rope |
| --- | --- | --- | --- | --- | --- | --- |
| Central Plan<br>(oracle) | Success | 0.90 | 1.00 | 0.96 | 0.70 | 0.50 |
| #Step | 4.0 | 8.4 | 8.8 | 8.6 | 2.3 |  |
| Roco<br>Dialog | Success | 0.75 | 0.70 | 0.70 | 0.70 | 0.70 |
| #Step | 4.7 | 7.9 | 9.1 | 5.4 | 2.4 |  |
| IoA | Success | 1.00 | 0.80 | 1.00 | 1.00 | 0.70 |
| #Step | 4.6 | 8.5 | 8.9 | 5.8 | 2.6 |  |

To evaluate IoA’s efficacy in orchestrating agents with heterogeneous observation and action spaces, we conduct experiments in the domain of embodied AI. This domain presents unique challenges, requiring agents to perceive, understand, and interact with their physical environment. We utilize RoCoBench (Mandi et al., ), a state-of-the-art benchmark designed to assess the collaboration and communication capabilities of embodied agents. RoCoBench comprises six collaborative tasks, each mandating two or three agents with partial, often distinct action space or observations of the environment to cooperate towards a common objective.

Experimental Setups:
We benchmark IoA against two baselines established by Mandi et al. (): (1) Central Plan, a centralized agent has complete environmental information and control over all embodied agents, and (2) Roco Dialog, a specialized multi-agent framework designed for this task, enabling agent communication and decision-making.

Given that RoCoBench requires agents to output action plans in a specific format rather than interact with tools, we adapt IoA to this scenario without integrating external agents. Instead, we provide environmental observations to two IoA clients and extract their action plans from their discussion. This setup allows us to evaluate IoA’s ability to manage agents with heterogeneous observation and action spaces. Detailed implementation specifics are available in Section A.4.3.
To ensure a fair comparison, we conduct 10 runs for both IoA and Roco Dialog for each task, reporting average success rates and steps taken. Results for Central Plan are sourced directly from Mandi et al. (). Note that the Pack Grocery task is omitted due to implementation errors in the benchmark release.

Results and Analysis:
Table 2 presents the average success rates and steps required for task completion. Remarkably, despite not being specifically optimized for embodied tasks, IoA outperforms Roco Dialog, a framework tailored for this benchmark, in four out of five tasks in terms of success rate. IoA achieves perfect scores on the Cabinet, Sandwich, and Sort tasks, demonstrating the robustness of its communication and collaboration mechanisms in enabling embodied agents with heterogeneous observation and action spaces to work synergistically towards common goals. Even more impressive is IoA’s performance relative to the Central Plan baseline, which benefits from full environmental observability. IoA’s success rates are superior or comparable to Central Plan across tasks, although it generally requires slightly more decision steps for task completion. Given that IoA is a general multi-agent framework not specifically designed for embodied AI tasks, the marginal increase in step count is a reasonable trade-off for its versatility and effectiveness.

The success of IoA in this embodied AI scenario highlights its versatility and effectiveness. It suggests that the principles underlying IoA, e.g., autonomous conversation flow control, are fundamentally generalizable, indicating IoA’s potential applicability in a wide range of real-world scenarios where agents must collaborate despite having different perspectives or capabilities.

### 3.4 Heterogeneous Knowledge: Retrieval-Augmented Generation

To evaluate IoA’s efficacy in orchestrating agents with heterogeneous knowledge, we conduct experiments on retrieval-augmented generation (RAG) tasks (Lewis et al., ). RAG tasks present a unique challenge where agents must retrieve relevant information from diverse sources and collaborate to synthesize accurate responses, making them an ideal testbed for assessing IoA’s ability to manage knowledge heterogeneity and facilitate effective inter-agent communication.

Experimental Setups:
We implement IoA with GPT-3.5-turbo-0125 as the core language model, following Apollo’s Oracle (Wang et al., ). To evaluate knowledge heterogeneity and its impact, we design three scenarios: 1) Heterogeneous Knowledge: Two clients access different evidence pools (Wikipedia/Google), testing IoA’s ability to manage knowledge heterogeneity. 2) Homogeneous Knowledge (2 Agents): Two clients access both pools, serving as a control to isolate heterogeneity effects. 3) Homogeneous Knowledge (3 Agents): Three clients access both pools, assessing scalability and knowledge redundancy trade-offs.

This design allows us to disentangle the effects of knowledge heterogeneity from agent count and knowledge redundancy. We evaluate across four datasets: TriviaQA (Joshi et al., ), Natural Questions (NQ) (Kwiatkowski et al., ), HotpotQA (Yang et al., ), and 2WikiMultiHopQA (2WMHQA) (Ho et al., ), using 250 randomly sampled question-answer pairs from each. Implementation details are in Section A.4.4.

**Table 3: Results for RAG task. IoA, based on GPT-3.5, performs on par with or better than GPT-4 across all tasks. Best results (excluding GPT-4) are in bold, and second-best are underlined. Heterogeneous means agents have different evidence pools, while Homogeneous means all agents access all evidence pools.**
| Model | TriviaQA | NQ | HotpotQA | 2WMHQA | Overall |
| --- | --- | --- | --- | --- | --- |
| GPT 4 | 0.902 | 0.692 | 0.566 | 0.284 | 0.611 |
| GPT 3.5 Turbo | 0.778 | 0.532 | 0.384 | 0.210 | 0.476 |
| + Zero-Shot CoT (Wei et al., ) | 0.772 | 0.588 | 0.410 | 0.190 | 0.490 |
| + Self Consistency (Wang et al., ) | 0.818 | 0.622 | 0.408 | 0.206 | 0.514 |
| + Reflxion (Shinn et al., ) | 0.762 | 0.586 | 0.378 | 0.254 | 0.495 |
| + Multi-Agent Debate1 (Du et al., ) | 0.798 | 0.648 | 0.394 | 0.186 | 0.507 |
| + Multi-Agent Debate2 (Liang et al., ) | 0.756 | 0.576 | 0.450 | 0.334 | 0.529 |
| Apollo’s Oracle (Homogeneous) | 0.834 | 0.662 | 0.542 | 0.350 | 0.597 |
| IoA + 2 Agents (Heterogeneous) | 0.803 | 0.708 | 0.478 | 0.449 | 0.610 |
| IoA + 2 Agents (Homogeneous) | 0.820 | 0.671 | 0.586 | 0.530 | 0.652 |
| IoA + 3 Agents (Homogeneous) | 0.908 | 0.682 | 0.575 | 0.519 | 0.671 |

Results and Analysis:
Table 3 demonstrates IoA’s remarkable performance across all datasets, often surpassing or matching GPT-4 despite being based on GPT-3.5. On two out of four tasks, IoA’s heterogeneous knowledge scenario outperforms homogeneous Apollo’s Oracle, showcasing IoA’s effectiveness in managing knowledge diversity. This configuration achieves the best performance on NQ and competitive results on other datasets, often outperforming single-model approaches and specialized frameworks like Apollo’s Oracle. This underscores IoA’s efficacy in facilitating information exchange and synthesis from heterogeneous sources, effectively compensating for individual agents’ knowledge gaps.

We also conduct experiments in homogeneous settings. IoA with 3 agents achieves the best overall performance, outperforming all baselines on TriviaQA and showing competitive results on other datasets. Interestingly, the 2-agent homogeneous configuration outperforms the 3-agent setup on HotpotQA and 2WikiMultiHopQA, suggesting that optimal agent configuration may be task-dependent. These results not only validate IoA’s effectiveness in RAG tasks but also highlight its potential as a versatile platform for managing both heterogeneous and homogeneous knowledge in multi-agent systems.

## 4 Analysis

### 4.1 Team Formation Precision

To evaluate the precision of IoA’s autonomous team formation mechanism, we developed a benchmark using GPT-4, comprising 625 diverse tasks paired with 1500 dummy agent profiles. This simulated environment allows us to assess the accuracy of both regular and nested team formation in a large-scale setting. Detailed data construction processes are available in Appendix C.

##### Experimental Design:

We evaluate two distinct scenarios: regular team formation and nested team formation. For regular team formation, each task is associated with 2 or more suitable agent profiles generated by GPT. For nested team formation, we generate a subtask for each original task that can or cannot be completed by the initially formed team, if not, an additional agent profile capable of addressing this subtask is generated. We evaluate whether the team can correctly decide when to enter the nested team formation stage, and evaluate the precision of the nested team formation.

We assess both settings using four metrics: Top@1 and Top@10 recall rates, Mean Rank (MR), and Mean Reciprocal Rank (MRR). Top@1 measures exact matches, while Top@10 accounts for semantic similarity, considering an agent as recalled if a recruited agent is among the top 10 most similar to a labeled agent. MR and MRR provide insights into the ranking quality of retrieved agents.

**Table 4: Performance of Team Formation Mechanisms. Regular denotes the initial team formation setting, and Nested denotes the nested team formation mechanism.**
|  | Top@1$\uparrow$ | Top@10$\uparrow$ | MR$\downarrow$ | MRR$\uparrow$ |
| --- | --- | --- | --- | --- |
| Regular | 41.4% | 64.9% | 27.4 | 50.1% |
| Nested | 59.7% | 81.8% | 10.6 | 66.5% |

Results and Analysis:
Table 4 presents the performance of both team formation mechanisms, each evaluated on its own specific dataset and setting. In the regular team formation scenario, which assesses the ability to form initial teams for given tasks, we observe a Top@1 recall of 41.4% and a Top@10 recall of 64.9%. This indicates that the mechanism can exactly match the labeled agents 41.4% of the time, and when considering semantic similarity, the retrieved agent fall into the top 10 similar agents to the labeled agent for 64.9% of the time. The Mean Rank (MR) of 27.4 and Mean Reciprocal Rank (MRR) of 50.1% suggest that, on average, relevant agents are ranked within the top 30 results, with a tendency towards high ranking.

For the nested team formation scenario, which evaluates the mechanism’s performance in a setting where subtasks may emerge requiring additional expertise, we see a Top@1 recall of 59.7% and a Top@10 recall of 81.8%. The MR of 10.6 and MRR of 66.5% indicate that relevant agents are typically found within the top 11 results, with a strong tendency towards very high rankings. These metrics suggest effective performance in this more dynamic setting.

These results demonstrate IoA’s capability to form precise teams in both initial task allocation and in scenarios where task requirements may evolve. The high recall rates, especially with similarity matching (Top@10), are crucial for addressing complex tasks that require diverse or specialized skills.

### 4.2 Cost and Sub-Optimal Communication Pattern Analysis

To evaluate the economic feasibility and potential for optimization of the IoA, we conduct a cost analysis on the open-ended instruction benchmark (Section 3.2), where AutoGPT and Open Interpreter are integrated. We compare the average cost per task for these agents when operating individually and when integrated into the IoA.

**Table 5: Cost analysis of standalone agents and IoA-integrated agents on the open-ended instruction benchmark.**
| Setting | Cost per Task |
| --- | --- |
| AutoGPT (Standalone) | $0.39 |
| Open Interpreter (Standalone) | $0.16 |
| AutoGPT (in IoA) | $0.33 |
| Open Interpreter (in IoA) | $0.13 |
| IoA Communication | $0.53 |
| IoA Communication (Dedup.) | $0.28 |
| IoA Overall | $0.99 |
| IoA Overall (Dedup.) | $0.74 |

As shown in Table 5, when integrated into IoA, the costs of both agents are decreased due to the task decomposition for each task. However, the IoA introduces an additional communication cost of $0.53 per task, resulting in an overall cost of $0.99.

Figure: Figure 6: An example of the repeated communication.
Refer to caption: x6.png

During our analysis, we observed unexpected and suboptimal communication patterns that contributed to the high communication cost. One notable pattern was the repetition of information, where the LLMs in the clients would repeat or rephrase previous chats from themselves or others, leading to a stagnation in progress. This phenomenon was particularly prevalent after several asynchronous task assignments. Although each task assignment did not require immediate waiting, as the conversation progressed, new decisions had to be made based on the conclusions from previously assigned and not yet completed asynchronous tasks. Despite providing the client LLMs with the option to switch the group chat state to pause & trigger, they sometimes fail to switch, as illustrated in Fig. 6. This drawback in LLM is also observed in other multi-agent work (Li et al., ; Mandi et al., ).

To quantify the impact of this suboptimal communication pattern, we manually removed the repetitions and recalculated the token numbers and corresponding costs. Surprisingly, this resulted in a nearly 50% reduction in communication costs, as shown in the ”Dedup.” rows of Table 5. This finding aligns with observations from other multi-agent communication frameworks, suggesting that while modern LLMs are well-aligned to be effective chatbot assistants, they may not be optimally aligned to be efficient communicating agents. Agents should not only complete the given tasks accurately but also communicate effectively with others, understanding conversation states and making proper decisions. This insight raises new research questions regarding the agent alignment of LLMs and highlights the need for further investigation in this area.

Despite the current cost overhead and suboptimal communication patterns, the IoA demonstrates significant potential for enabling effective collaboration among heterogeneous agents. By addressing these challenges through prompt optimization, protocol refinement, and the development of more sophisticated frameworks under the concept of IoA, we believe that the cost of communication can be significantly reduced. As research progresses, IoA and similar approaches will become increasingly attractive and economically viable solutions for complex multi-agent systems.

## 5 Related Work

##### LLM-based Agents

Recent advancements in LLMs, such as GPT (OpenAI, ), Claude (Anthropic, ) and Gemini (Reid et al., ), have led to the development of highly capable AI agents, which can engage in natural language interactions and perform a wide range of tasks. To enhance the capabilities of LLM-based agents, researchers have explored the integration of external tools and knowledge sources (Nakano et al., ; Yao et al., ; Schick et al., ; Shen et al., ), enabling agents to access and utilize relevant information beyond their pre-trained knowledge. The various agents have demonstrated significant progress in a wide range of domains, including operating system interactions, software engineering, and general AI applications. For instance, OS-Copilot facilitates generalist interactions across web browsers and code terminals (Wu et al., ), while OpenDevin focuses on autonomous software development tasks such as coding and debugging (OpenDevin Team, ). Other notable developments include XAgent for complex task solving (Team, ) and Voyager (Wang et al., ), an open-ended embodied agent leveraging LLMs for Minecraft game-playing. These advancements have laid the foundation for more sophisticated and versatile LLM-based agents, capable of autonomous task execution and continuous learning.

##### LLM-based Multi-Agent Systems

Building upon the success of individual LLM-based agents, researchers have begun to explore the potential of multi-agent systems composed of these agents. Early works demonstrated the feasibility of using LLMs to simulate multi-agent interactions and emergent behaviors (Park et al., ). Since then, various approaches have been proposed to enable effective collaboration and communication among LLM-based agents. Frameworks such as AgentVerse (Chen et al., ) and AutoGen (Wu et al., ) provide the necessary infrastructure for agent collaboration. In software development, multi-agent systems like ChatDev (Qian et al., ), MetaGPT (Hong et al., ) have shown promising results in automating coding, testing, and debugging processes. Despite these advancements, significant limitations remain, such as the lack of support for integrating diverse third-party agents, the inability to support distributed multi-agent systems, and the reliance on hard-coded communication protocols and state transitions. IoA aims to address these limitations and provide a more flexible and scalable platform for LLM-based multi-agent collaboration, paving the way for more advanced and practical systems that can tackle complex real-world problems effectively.

## 6 Conclusion

In this paper, we introduced IoA, a novel framework for LLM-based multi-agent collaboration inspired by the concept of the Internet. IoA addresses the limitations of existing multi-agent frameworks by providing a flexible and scalable platform for integrating diverse third-party agents, enabling distributed multi-agent collaboration, and introducing dynamic mechanisms for agent teaming and conversation flow control. Through extensive experiments on various benchmarks, we demonstrated the effectiveness of IoA in facilitating efficient collaboration among heterogeneous agents, consistently outperforming state-of-the-art baselines.
As the field of LLM-based agents continues to advance, we believe that IoA will serve as a foundation for future research and development in multi-agent collaboration. By enabling the integration of diverse agents with specialized skills and knowledge, our framework opens up new possibilities for leveraging existing agents that were developed independently. We hope that our work will inspire further research in this promising direction and contribute to the development of more advanced and impactful multi-agent systems.

## Appendix A Implementation Details of IoA

In this appendix, we provide a comprehensive overview of the implementation details for each module in the client and server layers of IoA.

### A.1 Message Protocol

Figure: Figure 7: Fields in the IoA message protocol.
Refer to caption: x7.png

To support the functionalities of IoA introduced in Section 2.4, we have designed a comprehensive agent message protocol that facilitates efficient communication and coordination among agents. The protocol, as illustrated in Fig. 7, consists of several fields that cater to the specific requirements of various mechanisms within the framework.

Firstly, the protocol includes the following header for all message types:

- •
sender (str): The name or unique identifier of the agent sending the message.
- •
state (enum): The current state of the group chat associated with the message, which can be either team formation or communication.
- •
comm_id (str): The unique identifier of the group chat to which the message belongs.

To support the autonomous team formation mechanism, the protocol incorporates the following fields:

- •
goal (str): The objective or task that the current group chat aims to accomplish.
- •
team_members (list[str]): The names or unique identifiers of the agents required for the current group chat.
- •
team_up_depth (int): The depth of the current nested team formation, used to determine if the maximum allowed depth has been reached.
- •
max_turns (int): The maximum number of discussion turns allowed for the current group chat. If exceeded, the group chat will be forced into the conclusion phase.

For facilitating the discussion phase, the protocol includes the following fields:

- •
content (str): The actual content of the current message.
- •
type (enum): Specifies the next dialogue state, which can be discussion, task assignment, or conclusion.
- •
next_speaker (list[str]): The name(s) or unique identifier(s) of the agent(s) expected to speak next. In the discussion state, next_speaker is limited to a single agent, while in the task assignment state, it can include multiple agents, indicating that the current message contains multiple task assignments.

To support the task assignment mechanism, the protocol incorporates the following fields:

- •
task_id (str): The automatically generated unique identifier for the current task.
- •
task_desc (str): The description of the task assigned to the client, extracted from the chat.
- •
task_conclusion (str): The conclusion or result provided by the client after completing the assigned task.
- •
task_abstract (str): A concise summary of the completed task.

Lastly, to support the pause & trigger mechanism, the protocol includes the following field:

- •
triggers (list[str]): A list of task IDs that require a trigger to be set.

By adhering to this comprehensive agent message protocol for sending and receiving messages, clients within IoA can effectively achieve autonomous team formation and conversation flow control. The protocol ensures that all necessary information is communicated among agents, enabling seamless collaboration and coordination in various task scenarios.

### A.2 Client

The client component of IoA plays a crucial role in enabling the integration and collaboration of heterogeneous agents. It consists of three layers: the Foundation Layer, the Data Layer, and the Interaction Layer. Each layer comprises several modules that work together to facilitate efficient communication, data management, and agent coordination. In this subsection, we provide a detailed overview of the implementation of each module within the client’s layers.

#### A.2.1 Foundation Layer

##### Network Infrastructure Module

In IoA, all clients maintain a persistent connection to the server using the WebSocket protocol, similar to an instant messaging application. When a client sends a message, it is transmitted to the server, which parses the comm_id field in the message and forwards it to the other clients in the corresponding group chat via their respective WebSocket connections. The real-time nature of WebSocket ensures that messages are delivered promptly, enabling clients to receive and respond to messages without delay.

##### Data Infrastructure Module

To support the data storage and retrieval requirements of the upper-level Data Layer modules, we employ SQLite as the primary database solution. SQLite provides a lightweight and efficient means of persisting and accessing data related to agent contacts, group information, and task management. By leveraging SQLite, the client can store and retrieve information about encountered agents, group chat details, and task assignments, ensuring data consistency and availability throughout the collaboration process.

##### Agent Integration Module

The Agent Integration Module defines the protocol that third-party agents must adhere to in order to seamlessly integrate with IoA. Currently, the agent integration protocol in IoA requires agents to implement a function def run(task_desc: str) -> str, which accepts a task description as input and returns a summary of the task completion. This simple yet effective protocol allows diverse agents to be incorporated into the framework, enabling them to contribute their unique capabilities to the collaboration process. As IoA evolves, the integration protocol can be extended to support more advanced functionalities and interaction patterns.

#### A.2.2 Data Layer

##### Agent Contact Module

The Agent Contact Module is responsible for maintaining a record of the clients that the current client has previously collaborated with. It stores information such as the names and descriptions of these clients, providing a valuable reference for future collaborations. The module aims to support the client in evaluating and storing collaboration outcomes after each task, allowing it to make informed decisions when forming teams for subsequent tasks. During the team formation process, the information stored in this module is included in the prompt to assist the client in selecting the most suitable partners based on prior experiences.

##### Group Info Module

The Group Info Module manages all group chat-related information, including the following fields:

- •
comm_id (str): The unique identifier of the group chat.
- •
goal (str): The objective or task that the group chat aims to accomplish.
- •
team_members (str): The list of agents participating in the group chat.
- •
state (str): The current state of the group chat (e.g., team formation, discussion, task assignment, conclusion).
- •
conclusion (str — None): The final outcome or conclusion reached by the group chat.
- •
team_up_depth (int): The depth of the nested team formation within the group chat.
- •
max_turns (int): The maximum number of communication turns allowed in the group chat.

By organizing and persisting this information, the Group Info Module enables clients to maintain a coherent view of the ongoing collaborations and their progress.

##### Task Management Module

The Task Management Module is responsible for storing and tracking the tasks assigned within each group chat. It maintains the following fields for each task:

- •
task_id (str): The unique identifier of the task.
- •
task_desc (str): The detailed description of the task.
- •
task_abstract (str): A concise summary of the task.
- •
assignee (str): The agent assigned to complete the task.
- •
status (enum): The current status of the task (e.g., pending, in progress, completed).
- •
conclusion (str — None): The final result or outcome of the task.

By keeping track of task-related information, the Task Management Module enables clients to monitor the progress of assigned tasks and ensures that all task-related data is readily available for reference and decision-making purposes.

#### A.2.3 Interaction Layer

##### Team Formation Module

As briefly introduced in Section 2.3.2, when a client receives a task, it is equipped with two essential tools: search_agent(desc: list[str]) -> list[agent] and launch_group_chat(team_members: list[str] | None) -> comm_id. The client must decide whether to utilize the search_agent tool to find agents on the server that match the specified description, or to directly call the launch_group_chat tool based on the discovered agents and historical collaboration information. If the client invokes launch_group_chat without specifying any agents, it implies that the task will be completed by a single agent. To prevent infinite loops, IoA imposes a limit on the maximum number of tool calls, set to 10 by default. If the client reaches this limit without successfully launching a group chat, it is forced to invoke the launch_group_chat tool to initiate the collaboration process.

##### Communication Module

The Communication Module handles the core functionalities of message generation and message reception. When a client generates a message, IoA processes it according to the agent message protocol. If the message type is conclusion, the client enters the conclusion phase, where it provides a final answer to the group chat goal based on the accumulated chat records and task completion information. In the case of a pause & trigger message, the framework prompts the client to generate the task IDs that require triggers and broadcasts them to all group members. For discussion or task assignment messages, they are directly broadcast to all participants in the group chat.

Upon receiving a message, the client parses it according to the agent message protocol. If the next_speaker field does not include the current client, the message is simply added to the group chat history. However, if the client is designated as the next speaker, it must take appropriate actions based on the message type. For discussion messages, the client generates a response to continue the conversation. In the case of sync or async task assignment messages, the client extracts its assigned task from the chat record, summarizes it, and specifies the relevant information to be passed to the integrated agent. The agent then executes the task based on the summarized description and relevant chat messages, returning the result upon completion. If the message type is pause & trigger, the client updates the corresponding task triggers in the Task Management Module.

The Communication Module, in conjunction with the other modules in the Interaction Layer and Data Layer, enables seamless and structured collaboration among agents. By adhering to the well-defined agent message protocol and leveraging the functionalities provided by the various modules, clients can effectively participate in discussions, assign tasks, and coordinate their actions to achieve the desired goals.

### A.3 Server

The server component of IoA serves as the central hub for agent coordination, communication, and management. It comprises three layers: the Foundation Layer, the Data Layer, and the Interaction Layer. Each layer contains modules that work together to facilitate agent registration, discovery, and message routing. In this subsection, we provide a detailed description of the implementation of each module within the server’s layers.

#### A.3.1 Foundation Layer

##### Network Infrastructure Module and Data Infrastructure Module

The Network Infrastructure Module and Data Infrastructure Module in the server are largely similar to their counterparts in the client. However, the server’s Data Infrastructure Module incorporates the use of the Milvus vector database to support the construction and maintenance of the Agent Registry. Milvus enables efficient similarity search and retrieval of agent information based on their characteristics, allowing the server to provide clients with the functionality to discover and match agents effectively.

##### Security Module

While the Security Module is not extensively utilized in the current implementation of IoA, we acknowledge its crucial role in ensuring the integrity and reliability of the framework in real-world deployments. This module is responsible for verifying and controlling the integration of third-party agents into the clients, preventing malicious agents from compromising the entire framework. As IoA evolves, the Security Module will be enhanced to provide robust authentication, authorization, and monitoring mechanisms, safeguarding the collaborative environment from potential security threats.

#### A.3.2 Data Layer

##### Agent Registry Module

The Agent Registry Module maintains a comprehensive record of all clients integrated into the server. When a client connects to the server, it is required to provide a detailed description of the integrated agent, including its name and capability description. This information is stored in the Agent Registry, enabling similarity matching based on agent characteristics. The Agent Registry serves as a central repository for agent information, facilitating agent discovery and team formation processes.

##### Session Management Module

The Session Management Module is responsible for managing the WebSocket connections of all online agents and keeping track of the group chats they participate in. It maintains a mapping between agents and their respective WebSocket connections, as well as the associations between agents and group chats. When a client sends a message, the Session Management Module ensures that the message is properly routed to all clients involved in the corresponding group chat, guaranteeing reliable and efficient communication within the collaborative environment.

#### A.3.3 Interaction Layer

##### Agent Query Module

The Agent Query Module handles incoming requests from clients seeking to discover and match agents based on specific characteristics. Upon receiving a query request, the module converts the provided characteristics into vector representations and performs similarity matching against the agents stored in the Agent Registry. The implementation of this module can vary depending on the specific requirements and scalability needs of the framework. For instance, techniques such as BM25 or other information retrieval methods can be employed to enhance the matching process and improve the relevance of the returned agent results.

##### Group Setup Module

The Group Setup Module is responsible for handling client requests to create new group chats. When a client submits a request to set up a group chat, specifying the desired team members, the Group Setup Module processes the request and initializes a new group chat instance. It assigns a unique comm_id to the newly created group chat and notifies all participating clients about their inclusion in the chat. The Group Setup Module works in conjunction with the Session Management Module to ensure that the necessary WebSocket connections and mappings are established for efficient communication within the group chat.

##### Message Routing Module

The Message Routing Module plays a critical role in facilitating communication between clients within group chats. When a client sends a message, the Message Routing Module receives the message and parses it according to the agent message protocol. Based on the comm_id specified in the message, the module identifies the corresponding group chat and forwards the message to all clients associated with that chat. The Message Routing Module leverages the information maintained by the Session Management Module to ensure accurate and timely delivery of messages to the intended recipients.

The server component of IoA, with its carefully designed modules and interactions, provides a robust and efficient infrastructure for agent coordination, communication, and management. By leveraging the capabilities of the Foundation Layer, Data Layer, and Interaction Layer, the server enables seamless agent discovery, team formation, and message exchange, fostering a collaborative environment where diverse agents can work together to achieve common goals.

As IoA continues to evolve, the server component will be further enhanced to incorporate advanced features such as load balancing, fault tolerance, and scalability, ensuring that the framework can handle the growing demands of real-world multi-agent systems. Additionally, the Security Module will be strengthened to provide comprehensive security measures, safeguarding the integrity and confidentiality of agent interactions within the framework.

### A.4 Implementation Details of Different Experiments

In this section, we provide an overview of the implementation details for each experiment conducted to evaluate the performance of IoA.

#### A.4.1 GAIA

For the GAIA benchmark, IoA integrated four ReAct agents: Web Browser, Code Executor, YouTube Transcript Downloader, and Wikidata Searcher. The tools provided to Web Browser and Code Executor agents are adapted from the AutoGen framework with minor modifications to ensure compatibility with IoA.
To address the YouTube-related tasks in GAIA, we develop a YouTube video transcript downloader based on PyTube(^4^44[https://github.com/pytube/pytube](https://github.com/pytube/pytube)). For videos without readily available transcripts, the tool employs the Whisper model to transcribe spoken language into text.
Similarly, we adapt the Wikidata tool from Langchain(^5^55[https://python.langchain.com/v0.1/docs/integrations/tools/wikidata/](https://python.langchain.com/v0.1/docs/integrations/tools/wikidata/)) to fit the IoA ecosystem. These adaptations showcases a key feature of IoA: when a task requires a specific tool, it can be easily integrated into the system through its implementation and agent adaptation, enabling it to participate in task completion.

Due to budget constraints, we conduct performance testing on the GAIA validation set. Despite this limitation, the results provide valuable insights into the effectiveness of IoA in handling complex, multi-step tasks.

Figure: Figure 8: Example instructions from different categories in our open-ended instruction benchmark
Refer to caption: x8.png

#### A.4.2 Open-Ended Instruction Benchmark

To create a diverse and challenging benchmark for evaluating the performance of IoA on open-ended tasks, we construct a set of 153 instructions spanning four categories: search & report, coding, math, and life assistance. The benchmark construction process involved three main steps:

First, we select the instructions based on the real-world complex tasks used by XAgent (Team, ). These instructions were categorized into the four aforementioned groups. Second, to increase the diversity of the benchmark, we manually create an additional 10 complex tasks. Finally, we use the Self-Instruct method (Wang et al., ) to generate approximately 200 instructions, using the previously selected instructions as seeds. After manual screening and modification, we obtained the additional 94 instructions, resulting in a total of 153 tasks. The benchmark eventually consists of 52 search & report tasks, 30 coding tasks, 30 math tasks, and 41 life assistance tasks. By incorporating a diverse set of open-ended instructions, this benchmark allows for a comprehensive evaluation of the performance and versatility of IoA in handling a wide range of real-world scenarios. We show one example instruction for each category in Fig. 8.

Evaluation Methodology.
For IoA, we consider the final conclusion generated by the agents as the final answer. However, since AutoGPT (Significant Gravitas, ) and Open Interpreter (Open Interpreter, ) complete tasks in multiple steps and do not inherently generate a conclusion, we prompted them to provide a detailed conclusion as the final answer after task completion.

Inspired by the pairwise comparison evaluation method used in MT-Bench (Zheng et al., ), we employ GPT-4 to evaluate the responses of IoA against AutoGPT and Open Interpreter. To mitigate potential biases introduced by the order of the responses, we alternate the order of the two responses when presenting them to GPT-4 for evaluation. A result is counted as a win for a system only when it is consistently determined to be superior to its competitor in both orderings. In cases where the performance is inconsistent across the two orderings, the result is considered a draw.

#### A.4.3 Embodied Agent Tasks

For the RocoBench experiments, we adhere to the original paper’s methodology, which relies on discussions and parsing specific formatted strings from the discussion results to determine the embodied agent’s actions, rather than using agents to call tools directly. We implement two clients that communicate without integrated agents, requiring them to output strings in the RocoBench format at the conclusion stage. These strings are then parsed and used to interact with the environment using RocoBench’s predefined parsing functions. This approach serves as a validation of IoA’s client implementation and communication mechanism design.

To accommodate the varying requirements of different tasks in RocoBench, we adopt task-specific settings. For the Sort, Sandwich, and Sweep tasks, which exhibit strong interdependencies between steps, we retained the chat history and continued each new action discussion based on the previous group chat. In contrast, for the Cabinet and Rope tasks, where the steps were less interdependent, we initiated a new group chat for each action to optimize costs. Other settings remained consistent with the Roco Dialog baseline.

#### A.4.4 Retrieval-Augmented Generation

For the retrieval-augmented generation (RAG) question-answering task, we follow the settings outlined in Apollo’s Oracle. We provide agents with two evidence pools: one derived from Wikipedia and the other from Google. For Wikipedia, we utilize Pyserini’s pre-built index of Wikipedia content up to January 20, 2021, retrieving the top 10 most relevant results for each query. For Google, we directly access the Google Search API, returning the top 5 most relevant results for each query. These tools were made available to the client-side LLMs, enabling them to query relevant information during discussions and ultimately provide well-informed answers.

To evaluate the performance of IoA on the RAG task, we randomly sample 500 entries from the validation or test sets of the four datasets. After the model generates answers, we employ GPT-4 for answer evaluation. Specifically, we provide GPT-4 with the dataset answers and the model’s answers, requiring it to output its reasoning in a Chain of Thought (CoT) manner before providing a final correctness judgment.

## Appendix B Visualization of RocoBench

Figure: (a) Cabinet
Refer to caption: extracted/5722461/figs/cabinet.png

We provide the visualization of RocoBench at Fig. 9. The cabinet task requires three agents to collaborate: two agents open and hold the cabinet door while the third agent retrieves two cups from inside the cabinet and places them onto coasters that match the color of the cups. The sweep task involves two agents coordinating their actions: one agent controls a broom to sweep cubes, while the other agent holds a bucket to collect the cubes, and finally, they dump all the cubes into a dustbin. In the sandwich task, two agents work together to pick up ingredients and stack them according to a given recipe. The sort task requires three agents to place three cubes onto coasters with matching colors. Since each agent can only reach a limited area, they must coordinate their movements. Lastly, the rope task involves agents moving a rope into a bracket. They must communicate effectively to decide the correct path for maneuvering the rope.

## Appendix C Simulated Environment for Team Formation Evaluation

### C.1 Regular Team Formation simulated environment Construction

To construct a simulated environment for evaluating the regular ,team formation mechanism, we employ GPT-4-1106-preview to generate a diverse set of tasks and agents. The dataset construction process involved the following steps:

- 1.
Task Generation:
•
Using ChatGPT-4, we generate 399 distinct categories of theme keywords, covering various domains such as sports, lifestyle, and entertainment.
•
From these categories, we randomly select 25 themes and task GPT-4 with generating task descriptions related to at least four themes from the selected set, thus obtaining a task that require diverse agents with different capabilities.
•
Task descriptions are generated in JSON format using the GPT-4 API, ensuring a structured and consistent representation.
- 2.
Agent Generation:
•
After generating the tasks, for each task, we again prompt GPT-4 to construct at least two agents with varying capabilities for the given task, including the name of the agent, the type of the agent and the description of the agent.
•
The agent profile format is designed to align with the server-side agent registry, facilitating seamless integration and interaction within IoA.

An example of a generated task description in JSON format is as follows:

Similarly, an example of an agent profile in JSON format is:

A complete example with agent profiles and task description in JSON format is:

### C.2 Nested Team Formation simulated environment Construction

In a similarly way, in order to construct a simulated environment for evaluating the nested team formation mechanism, we also employ GPT-4-1106-preview to generate two diverse sets of tasks and agents. The dataset construction process involved the following steps:

- 1.
Sub-tasks Completed by Existing Agents:
•
Su-btask Generation:
–
Based on the dataset that we have constructed for regular team formation, we randomly select 300 sets as the original dataset.
–
For tasks in the original dataset, we prompt GPT-4 to construct a sub-task that can be completed by an existing agent, with the agent being selected by GPT-4.
–
Sub-task description are generated in JSON format using the GPT-4 API with the existing agent, ensuring a structured and consistent representation.
- 2.
Sub-tasks Completed by Additional Agent:
•
Sub-task and Agent Generation:
–
After generating the sub-tasks for exiting agent, we take the rest of sets as the another original dataset.
–
The difference for sub-task completed by existing agent is that we prompt GPT-4 to construct a sub-task requiring a very specific expertise.
–
Meanwhile, we also prompt GPT-4 to construct an agent with distinct capabilities compared to the existing agents to complete the generated sub-task, including the name of the agent, the type of the agent and the description of the agent.
–
Sub-task description and additional agent are generated in JSON format using the GPT-4 API ensuring a structured and consistent representation.

An example of a generated sub-task description with existing agent in JSON format is as follows:

Similarly, an example of a generated sub-task description with additional agent in JSON format is:

By generating a couple of diverse sets of tasks and agents, we create a comprehensive simulated environment for evaluating the regular team formation mechanism and the nested team formation mechanism. This environment enables us to assess the effectiveness of IoA in assembling appropriate teams to complete task requirements, addressing the limitations of existing benchmarks in providing suitable large-scale agent evaluation scenarios.

## Peer Reviews

confidence: 4
contribution: 3
initial_rating: 6
presentation: 3
questions: - How does IoA handle latency and data synchronization when agents are distributed across devices in real time?

- How does the protocol for agent integration address security, especially for third-party agents that may have differing trust levels? Could the authors expand on IoA’s security measures, especially regarding agent registration and message routing?

- Can the FSM for conversation flow control be adapted or scaled effectively if used with a larger number of agents than tested in the experiments? How adaptable is the finite-state machine-based flow control to tasks requiring high real-time interaction or rapid state changes?
soundness: 3
strengths: - Innovative Conceptual Framework: The IoA draws a compelling parallel between the functionality of MAS and the Internet, introducing layered architecture and team formation protocols that offer adaptability and scalability.

- Comprehensive Experiments: The paper provides a well-rounded experimental design, including benchmarks that demonstrate the system’s effectiveness across multiple task categories.

- Task-Specific Improvements: IoA demonstrates improved performance in benchmarks like the GAIA and RAG, highlighting its potential advantage over existing MAS in facilitating agent cooperation and integrating heterogeneous tools.
summary: This paper proposes the "Internet of Agents" (IoA) framework to facilitate enhanced collaboration among autonomous agents using large language models (LLMs). Inspired by the Internet’s structure, IoA aims to address the integration challenges seen in current multi-agent systems (MAS). This is achieved through three key innovations: a protocol for integrating diverse agents, a layered architecture resembling an instant-messaging framework, and mechanisms for dynamic team formation and conversation flow. Through a series of experiments, the paper claims that IoA enables more effective collaboration than existing MAS frameworks, particularly in domains like retrieval-augmented generation (RAG) and embodied AI tasks.
weaknesses: - Lack of Detailed Evaluation on Real-World Applications: While the experimental benchmarks are extensive, the paper lacks real-world application scenarios that demonstrate the IoA’s effectiveness in real world environments that require distributed settings. It is not unclear why GAIA benchmarks would need agents over internet instead of a simple central multi-agent system.

- Scalability and Performance Analysis: The paper lacks analysis on IoA’s computational overhead and network latency issues, especially when scaled to large numbers of agents across different devices distributed settings. An understanding of these scalability and performance trade-offs is critical.

- Vagueness in Mechanisms for Conversation Flow Control: The conversation flow control relies on LLMs and a finite state machine (FSM) for transitions, but the scalability of this approach when coordinating many situations with many states is not well justified. It would be great to have some ablation studies.

- Limited Insight into Integration of Third-Party Agents: The implementation of heterogeneous agent integration is described conceptually, but details on handling diverse architectures and security considerations when integrating third-party agents are lacking.

- Limited Novel Research Contributions: The paper’s focus on architecture and engineering limits its contribution to ML research. While the framework offers novel infrastructure, the lack of new research methodologies or performance optimizations in agent interactions might reduce its appeal in ML-centric venues.

---

confidence: 3
contribution: 4
initial_rating: 8
presentation: 4
questions: It would be beneficial to provide additional examples related to the constructed benchmark and to illustrate the specific steps undertaken by IoA.

GPT-4 might occasionally give higher evaluation scores or exhibit overconfidence. Could you discuss any potential biases or limitations associated with using this evaluation method in your benchmarks and whether you considered alternative evaluation approaches.
soundness: 3
strengths: The paper is well-written and organized, with the key components of IoA clearly illustrated and easy to follow.

The experiments are comprehensive, assessing IoA's capability to integrate agents with heterogeneous tools on the GAIA benchmark. It introduces a robust benchmark comprising 153 open-ended instructions spanning four diverse categories. The results illustrate IoA's effectiveness in integrating, orchestrating, and enabling independently developed agents with heterogeneous architectures. Further experiments with RoCoBench highlight IoA's ability to enhance the communication and collaboration capabilities of embodied agents. 
Moreover, in the RAG question-answering domain, IoA also surpasses existing methods.
summary: This paper introduces the Internet of Agents (IoA), a novel framework for LLM-based multi-agent collaboration, inspired by the concept of the Internet. The framework aims to facilitate collaboration among autonomous agents by addressing the limitations of existing multi-agent frameworks, including ecosystem isolation, single-device simulation, and rigid communication and coordination. IoA consists of two core components: the server and the client. The server acts as a central hub controller, while the client serves as a wrapper for individual agents, enabling the necessary communications and protocols. The IoA architecture has three layers, i.e., interaction, data, and foundation layers, they collectively accelerate agent collaboration through the network. Experiments conducted in various settings demonstrate the effectiveness and versatility of IoA in facilitating efficient collaboration among heterogeneous agents.
weaknesses: In Section 3.2, while the paper constructs 153 open-ended instructions spanning four categories—search & report, coding, math, and life assistant—there is a lack of sufficient or list of examples (only one figure) to illustrate whether the questions are complex and require multi-step reasoning, or if they can be directly solved.  Therefore, the authors could include an appendix with a representative sample of tasks & solutions from each category, or provide a link to the full benchmark.

Additionally, the paper primarily employs GPT-4 as an impartial judge of response quality, but IoA might require more steps than competitors such as AutoGen.

---

confidence: 4
contribution: 3
initial_rating: 5
presentation: 1
questions: How where these three specific benchmarks chosen?

The workflow of the conversational state machine is unclear to me. How are the tasks broken down into components? 

Each agent has a LLM component that manages state transitions, and which other components must agents have, to be part of this framework? 

Are only LLM-based agents able to participate in the framework?

Is it possible to present results (e.g. Table 3) as a bar plots with confidence intervals? If not, why?
soundness: 2
strengths: Inventing a "language" that can enable information transfer between different versions of AI agents is an exciting research question. It is certainly a useful idea, as proliferation of AI agents comes with a proliferation of agent versions and brands. At this stage, the question is still rhetorical rather than practical, as it took decades to build countless networking protocols for wireless routers and phones, like SIP, H323, TCP, UDP,.... In the current work the authors touch upon a novel question of introducing such as language, and take a step toward considering what would this language look like.
summary: This paper introduces the Internet of Agents framework for multi-agent collaboration, where agents from different developers communicate via an instant-messaging-like architecture and work in teams.
Communication is implemented by abstracting several conversational states, and implementing a finite-state machine to support state transition for agents.
The set of states includes 5 states, representing discussion, synchronous task assignment, asynchronous task assignment, pause & trigger, and conclusion, so and most of the "work" happens in the discussion state (this was not very clear to me).   Each agent has a LLM-based component which determines state transitions and selects the subsequent speaker.
The framework is evaluated using experiments with three types of tasks where teams of agents communicating using Internet of Agents framework are compared to existing multi-agent systems.
weaknesses: I feel like the authors miss the opportunity to focus the argument as a rhetorical/philosophical consideration to build an analogy with internet communication protocols.
Given the novelty of the issue, the system is still a toy and the experimental evaluation does not look as convincing as the conceptual notion of the potential that such a framework could be. 

Part of this general presentation issue, I find the Figure 1 to be much too cluttered. Maybe one way to approach this is to use an open source diagram creation tool, like draw.io, to make a clean arrows and boxes diagram with minimal text, showing how the various components interact. 

The paper could benefit from a few task workflow examples.

Overall all these comments are referring to one common point, which is lack of focus and clarity. My impression from this paper is that this is a worthy subject, but it is difficult to assess (rather than infer) what was done.

---

confidence: 3
contribution: 3
initial_rating: 8
presentation: 4
questions: How does performance scale with increasing number of agents?
soundness: 3
strengths: 1. The architecture is novel and the design is well-motivated which address three key issues in typical multi-agent systems (MAS). 
2. The technical foundation is clear as there is rigorous formalization of key mechanisms and detailed ablation studies showing importance of each component
3. The evaluation is comprehensive as it include a variety of benchmarks testing different aspects of agent heterogeneity along with strong empirical results across all tasks. (GPT3.5-based IoA agents outperforming GPT4 baselines)
summary: This paper introduces the Internet of Agents (IoA), a framework for enabling distributed collaboration among heterogeneous LLM-based agents. The key innovations include: 
(1) a protocol for distributed agent collaboration: a multi-layered architecture that enables agents to operate across different devices and locations, where each agent maintains its own "WebSocket" connection to a central server that handles message routing and coordination.

(2) an instant-messaging-like architecture for agent discovery and teaming: agents can search for collaborators based on capability descriptions and form nested teams, implemented through a central registry that maintains agent capabilities and allows semantic matching for team formation

(3) dynamic mechanisms for conversation flow control: a finite state machine approach that manages conversation states (discussion, task assignment etc.,), where LLMs autonomously decide state transitions and next speakers to maintain structured dialogue

(4) a protocol for integrating third-party agents: a standardized interface that requires agents to implement a simple `run()` function accepting task descriptions and returning results, allowing agents built under different protocols (AutoGPT or OpenInterpreter) to be wrapped and integrated into the framework.

IoA (GPT3.5) is evaluated across GAIA benchmark, open-ended instructions, embodied AI tasks, and retrieval-augmented generation, and IoA consistently outperformed other baselines on GAIA, open-ended instruction benchmark and matches or exceeds GPT4 performance on IoA.
weaknesses: One major concern about this framework is the cost (compute/financial) as Table 6 showed IoA is much more expensive than other multi-agent frameworks like AutoGPT and Open Interpreterm which might limit deployment of this frame at scale.

---

confidence: 4
contribution: 4
initial_rating: 8
presentation: 4
questions: - Really cool that you drew inspiration from Speech Act Theory for this work. Have you considered what Rational Speech Act has to offer in this case? Would be neat to see it leveraged to deal with things like recursive reasoning (theory of mind), own uncertainty and uncertainty of other agents, etc.
- How does the system handle potential deadlocks in the conversation state machine? Are there specific examples of potential deadlock scenarios you've considered? Can you describe any mechanisms or safeguards implemented to prevent or resolve such deadlocks in the conversation flow?
- What mechanisms ensure fair resource allocation when multiple agent teams are operating simultaneously?
- How does the framework maintain consistency when agents have conflicting knowledge or goals?
- Could the authors elaborate on the scalability limits of the nested team formation approach?
- What strategies are employed to prevent malicious agents from disrupting team collaboration? Is that just offloaded to the Security Module?
soundness: 3
strengths: - The authors present a well-motivated and timely contribution given the rapid advancement of autonomous agents and the need for frameworks to orchestrate their collaboration
- The layered architecture design is elegant and comprehensive, with clear separation between interaction, data, and foundation layers for both server and client components
- The experimental evaluation is thorough, testing the framework across diverse scenarios including general assistance, embodied AI tasks, and retrieval-augmented generation
- The nested team formation mechanism is theoretically sound, with formal analysis showing reduced communication complexity compared to fully connected structures
- The finite state machine approach to conversation control is well-grounded in Speech Act Theory and provides a principled way to manage agent interactions
summary: The authors propose the Internet of Agents (IoA), a novel framework for enabling collaboration between heterogeneous AI agents distributed across different devices. Drawing inspiration from the Internet's architecture, IoA introduces key mechanisms including agent registration/discovery, nested team formation, conversation flow control using finite state machines, and flexible task assignment. The framework addresses limitations of existing multi-agent systems like ecosystem isolation, single-device constraints, and rigid communication pipelines.
weaknesses: - While the authors demonstrate strong empirical results, the theoretical analysis of the framework's properties (e.g., convergence guarantees, scalability limits) could be strengthened
- The evaluation focuses primarily on task performance metrics. Additional analysis of system properties like latency, resource usage, and communication overhead would be valuable (I do see some of this in Appendix E)
- The authors could expand on potential failure modes and mitigation strategies, particularly for scenarios with unreliable network connections or agent failures
- The security implications of allowing distributed agents to collaborate deserve deeper treatment, including potential vulnerabilities and safeguards. I appreciate that the authors included the Security Module in the schematic, but think having a bit more discussion of it (in the appendix) could be beneficial

Meta-review: By drawing inspiration from the concept of the Internet, this paper proposes an LLM-based multi-agent collaboration framework, Internet of Agents (IoA).  Experimental results have demonstrated that IoA can enhance multi-agent collaboration. This work proposed a novel, technically solid framework for multi-agent systems. All reviews are positive and the authors have addressed reviewers' concerns.

Decision: Accept (Spotlight)