MorphAgent: Empowering Agents through Self-Evolving Profiles and Decentralized Collaboration

## Abstract

Abstract Large Language Model (LLM) based multi-agent systems (MAS) have shown promise in tackling complex tasks, but often rely on predefined roles and centralized coordination, limiting their adaptability to evolving challenges. This paper introduces MorphAgent ,
a novel framework for decentralized multi-agent collaboration that enables agents to dynamically evolve their roles and capabilities .
Our approach employs self-evolving agent profiles, optimized through three key metrics, guiding agents in refining their individual expertise while maintaining complementary team dynamics. MorphAgent implements a two-phase process: a warm-up phase for initial profile optimization, followed by a task execution phase where agents continuously adapt their roles based on task feedback.
Our experimental results show that MorphAgent outperforms traditional static-role MAS in terms of task performance and adaptability to changing requirements, paving the way for more robust and versatile multi-agent collaborative systems.
Our code will be publicly available at https://github.com/LINs-lab/learn2collaborate .

## 1 Introduction

The rapid advancement of Large Language Models (LLMs) (Achiam et al., ; Touvron et al., ) has ushered in a new era of artificial intelligence, enabling the creation of sophisticated AI agents capable of tackling complex tasks across various domains (Nakajima, ; Torantulino, ).
As these AI systems become more intricate, there is a growing need for effective collaboration mechanisms that allow multiple agents to work together.
This collaborative approach, known as Multi-Agent Systems (MAS) (Han et al., ), has shown great promise in addressing challenges that are too complex or diverse for single-agent systems (Hong et al., ; Liu et al., ).

While existing MAS implementations have shown promising results, they often rely on predefined roles (Li et al., ), centralized coordination (Guo et al., ; Chen et al., ), or rigid organizational structures (Wang et al., ; Hong et al., ).
These approaches limit cooperative resilience within MAS (Chacon-Chamorro et al., ), which focuses on robustness and adaptability in dynamic, unpredictable environments.
Figure 1 presents two examples to illustrate the real-world challenges with details elaborated below:

###### Example 1.1 (Domain shift) .

Domain shift refers to a change in the characteristics or requirements of a task as it progresses through different phases or contexts, presenting new challenges and requiring different skill sets.
For instance, a scientific research project could begin with literature review, move to experiment design, and conclude with result analysis and paper writing.
These transitions demand a flexible and adaptive multi-agent system that can seamlessly adjust its collaborative strategies and agent roles as the task progresses.

###### Example 1.2 (Node Failure) .

In real-world applications, the reliance on centralized coordination in many existing MAS approaches (Chen et al., ; Hong et al., ) introduces a potential single point of failure.
Consequently, the single point of failure can lead to cascading failures in MAS, where the entire system collapses if the central coordinator becomes unavailable.
This vulnerability highlights the need for more robust, decentralized approaches to multi-agent collaboration (Chacon-Chamorro et al., ).

In this paper, we address these above challenges through a fully decentralized approach, where agents autonomously adapt their roles and strategies.
However, a naive implementation of fully decentralized MAS presents inefficiencies for role assignment since the agents require many interaction rounds to converge on role assignments.
Without a structured mechanism for role optimization, this process can lead to suboptimal role distributions and slow adaptation to changing task requirements,
reducing the overall effectiveness of the system.
This underscores the need for a more sophisticated approach to profile optimization in decentralized multi-agent systems.

Figure: Figure 1: Illustration of challenges in multi-agent systems (MAS) under domain shift and node failure scenarios. (a) In the domain shift scenario, a user requests a paper, which is outside the expertise of the MAS that is optimized for software engineering tasks. The agents (Product Manager, UI/UX Designer, Software Developer) struggle to fulfill this request due to the mismatch in domain expertise, leading to a suboptimal result. (b) In the node failure scenario, a user requests a program, but due to the failure of the Product Manager node, the MAS experiences a cascading failure and is unable to complete the task.
Refer to caption: extracted/5939005/sources/figures/introduction.png

To address above challenges, our design is motivated by the need to balance the benefits of decentralization with the efficiency of structured role optimization:
the effective collaboration in a multi-agent system requires not just individual agent capability, but also a complementary distribution of roles that aligns with the task at hand.
We introduce agent profiles as dynamic representations of evolving capabilities and responsibilities.
Specifically, our approach employs quantitative metrics such as Role Clarity Score, Role Differentiation Score, and Task-Role Alignment Score to encourage self-optimization.
By optimizing these metrics for agent profiles, our approach promotes clear role definition, diverse specialization, and task relevance, enhancing the system’s adaptive capacity in dynamic environments.

Building on these insights, we propose a decentralized multi-agent system MorphAgent with adaptive profile optimization.
Our method incorporates two key phases, namely, a warm-up phase for initial role development, and a dynamic task execution phase, thereby enables our system to achieve rapid initial role optimization while maintaining the adaptability necessary for long-term effectiveness.
By allowing agents to autonomously adjust their profiles throughout the task execution, our method preserves the benefits of decentralization such as robustness and scalability while mitigating the potential inefficiencies of unstructured role assignment.

Contributions. We summarize the key contributions of this paper as follows:

- •
Decentralized Collaboration Framework: We introduce a novel, fully decentralized multi-agent collaboration framework designed to enhence system resilience and adaptability in complex tasks.
By leveraging adaptive role optimization and fully decentralized coordination,
our approach demonstrate robustness to node failures and adaptability to domain shifts.
- •
Autonomous Collaboration Mechanism: We develop an automatic collaboration system that does not depend on any critical agent or node.
This approach distributes the process of decision-making and task execution across all agents,
ensuring continued operation and performance even in the face of individual agent failures.
- •
Adaptive Role Optimization: We propose an adaptive role adjustment mechanism based on continuous profile optimization.
By optimizing for role clarity, differentiation, and task alignment,
our method enables a more flexible and robust form of collaboration.
This mechanism allows agents to dynamically adjust their roles in response to dynamically task requirements and team composition changes.
- •
Empirical Validation: We provide comprehensive empirical evidence of our method’s effectiveness through extensive experiments on standard benchmarks and custom-designed complex tasks.
Our results show significant improvements over state-of-the-art baselines in terms of task performance, adaptability, and robustness to failures.

###### Example 1.1 (Domain shift) .

###### Example 1.2 (Node Failure) .

## 2 Related Work

### 2.1 LLM-based Multi-Agent Systems

The emergence of Large Language Models (LLMs) (Achiam et al., ; Touvron et al., ) has led to LLM-based autonomous agents capable of tackling complex tasks similar to humans, like BabyAGI (Nakajima, ) and AutoGPT (Torantulino, ).
However, single LLM agents often struggle with cooperative work, such as software engineering (Jimenez et al., ).
To address these limitations, recent study have proposed LLM-based multi-agent systems (MAS) (Han et al., ; ), where multiple AI agents collaborate on complex tasks.

However, current approaches often rely on predefined roles, centralized coordination, or rigid organizational structures, which may limit their flexibility and adaptability.
For instance, CAMEL (Li et al., ) and ChatEval (Chan et al., ) employ agents with predefined roles through role-playing to effectively complete different tasks and achieve common goals.
While this approach shows effective cooperation, it can struggle to adapt to tasks that require unforeseen skills.
MegaAgent (Wang et al., ) introduces autonomous task splitting and execution in centralized coordination, demonstrating how multi-agent systems can outperform single agents by leveraging collective capabilities.
Nevertheless, this centralized approach can create bottlenecks in large-scale systems and be damaged by single points of failure in real-world environments.
Recent works like MetaGPT (Hong et al., ) introduce human workflow in rigid organizational structures, organizing agents in a manner similar to a software company showing significant improvements in code-generation benchmarks
but such rigid structures cannot generalize effectively to other domains.

Our work addresses these limitations by focusing on a more general setting, where all agents are initialized homogeneously without predefined roles or organizational structures.
This approach aims to examine how agents learn to cooperate and specialize over time through interaction and experience to tackle diverse and evolving challenges.

### 2.2 Organization Optimization for MAS

Recent research in LLM-based Multi-Agent Systems (MAS) has focused on optimizing organizational structures (Guo et al., ; Zhuge et al., ) and enhancing agent performance (Zhang et al., ) to reduce communication costs and increase team efficiency.
Approaches like AgentVerse (Chen et al., ), Criticize-Reflect (Guo et al., ) and MegaAgent (Wang et al., ) rely on centralized mechanisms, where a single role or a subset of agents monitor and evaluate the system’s overall trajectory.
While effective in certain scenarios, these centralized methods may face scalability issues and potential bottlenecks in large-scale MAS.

Our research proposes a paradigm shift towards a fully decentralized approach, leveraging the inherent capabilities of LLM-based agents for self-reflection and self-correction (Madaan et al., ; Shinn et al., ; Renze & Guven, ).
In this decentralized framework, agents can dynamically adjust their responsibilities (profile) based on the current context and their evolving understanding of the task environment.
As agents learn to specialize and collaborate without central coordination, the system can scale more effectively to handle increasingly complex tasks and larger agent populations, mitigating the risk of context overload for central coordinating agents.

### 2.3 Standard Operating Procedure based MAS

Another significant strand of research has explored more structured and controlled methodologies in LLM-based multi-agent systems.
Among these, Standard Operating Procedure (SOP) based approaches like AgentCoder (Huang et al., ) and MetaGPT (Hong et al., ), have demonstrated considerable performance gains.
These works define a standardized pipeline for agents, which provides a determined framework for task execution and inter-agent communication.
GPTSwarm (Zhuge et al., ) further extends this concept by conceptualizing each agent as a subnet composed of action nodes, framing agent collaboration as a graph of action nodes.
This approach enables efficient task-solving for specific and well-defined task by identifying the optimal action sequence for information flow and task execution.

While SOP-based approaches provide an efficient method for coordinating complex tasks by following predefined procedures in specific scenarios, they lack flexibility.
When the established pipeline does not fit the current task, the system is unable to adjust. Consequently, such rigid frameworks cannot adapt effectively to dynamic environments.

In our work, we propose a more flexible framework that combines the strengths of multi-agent collaboration with the autonomous planning capabilities of advanced agents.
Instead of enforcing rigid SOPs, our framework dynamically develops and refines collaborative strategies using the inherent planning abilities of advanced LLM-based agents (Huang et al., ; Guan et al., ; Wang et al., ).
Moreover, our approach fosters agents to efficiently and optimally adapt their roles to the evolving demands of the task, enhancing overall performance and robustness.

## 3 Autonomous Collaboration for Fully Decentralized MAS

In this section, we present a novel decentralized multi-agent system which incorporated with a dynamic profile-based collaboration mechanism.
Our key innovation lies in a two-phase process, as detailed in Appendix A, Algorithm 1: (1) *a warm-up phase* that optimizes agent profiles, and (2) *a task execution phase* where agents iteratively observe the environment, take actions, and update their profiles based on results and changes in the task state.
To begin, we provide an overview of our multi-agent cooperation process in Section 3.1, followed by a detailed description of our dynamic profile-based collaboration mechanism in Section 3.2.
Finally, we present the collaborative problem-solving process of our MAS in Section 3.3.

### 3.1 System Overview

Complex tasks require adaptive problem-solving approaches that go beyond traditional centralized systems, which are vulnerable to bottlenecks and failure points.
In centralized systems, a single coordinator is responsible for breaking down tasks and assigning them to individual agents.
However, if the coordinator fails or communication is disrupted, the entire system risks collapsing.
Additionally, fixed roles within such systems prevent agents from adjusting to shifting task requirements, resulting in inefficiencies.

To develop a novel decentralized system, where multiple autonomous agents collaborate on complex tasks without predefined roles or centralized coordination,
we introduce a fully decentralized multi-agent system, MorphAgent comprising three key components—namely, (i) Autonomous Agent, (ii) Auxiliary Agent, and (iii) Environment—each playing a crucial role in enabling autonomous, decentralized collaboration, as detailed in the following subsections.

#### (i) Autonomous Agent.

The autonomous agent is built upon a LLM, e.g., GPT-4 (Achiam et al., ), which provides it with advanced reasoning and language understanding capabilities.
It is primarily composed of a dynamic profile and utilizes the ReAct framework (Yao et al., ) combined with Reflexion (Shinn et al., ) to guide its behavior.
The dynamic profile, which defines each agent’s roles and responsibilities, is central to how agents update and adapt, and will be discussed in detail in Section 3.2. Here, we focus on the operational mechanics of the agent.

Each agent follows the Observe-Think-Act cycle, where it first gathers information from the environment and other agents in the Observe phase.
In the Think phase, it uses its reasoning abilities to process the information and plan its next move as presented in Algorithm 1’s Line 13.
Finally, in the Act phase, the agent decides to either $\operatorname{EXECUTE}$ or $\operatorname{SKIP}$ a task based on its current capabilities and the task’s requirements.
After executing a task, the agent reflects on the outcomes, incorporating feedback into its memory for future decisions. This process is detailed in Algorithm 1’s Line 18.
The continuous cycle enables agents to adapt over time, refine their strategies based on feedback, and collaborate more effectively to address the specific problem at hand.

#### (ii) Auxiliary Agent.

The auxiliary agent serves as a middleware component that facilitates interaction between autonomous agents and the environment, without directly contributing to problem-solving.
This design allows for efficient management of agent interactions and environmental feedback while maintaining the decentralized nature of our system.
By handling technical details, the auxiliary agent allows the autonomous agents to focus on high-level problem-solving strategies.

The main function of the auxiliary agent is to translate agent decisions into environmental operations and relays feedback from the environment back to the agents.
For example, when an agent decides to execute Python code, the auxiliary agent runs the code in the environment, captures the output or errors from the environmental feedback, and provides this feedback to the multi-agent system.
Thus the auxiliary agent ensures that autonomous agents can concentrate on strategic problem-solving while it manages execution and feedback processes.

#### (iii) Environment.

The environment receives the instructions from users, processes them into messages, and the auxiliary agent is responsible for collecting and forwarding these messages within the environment to autonomous agents.
Additionally, the environment is equipped with a mechanism to evaluate agent profiles, providing feedback that agents can use to refine and adjust their roles and strategies.
This process ensures that agents continuously improve their task alignment and specialization, leading to more efficient collaboration and better overall system performance as task conditions evolve.

### 3.2 Dynamic Profile-Based Collaboration Mechanism

Traditional multi-agent systems (MAS) (Hong et al., ; Li et al., ) with predefined roles and static structures struggle to adapt to domain shift, leading to suboptimal performance when faced with unexpected changes or new challenges.
To address this, we introduce a dynamic profile mechanism, as prensented in Algorithm 1’s Line 4 and 22, enabling agents to continuously adjust their roles and skills based on interaction and task requirements.
We begin with the concept of agent profiles, followed by the key metrics used to evaluate and optimize these profiles.

#### Profile.

The concept of agent profiles encapsulates an agent’s evolving role, capabilities, and expertise, serving as a dynamic representation of the agent’s identity within the multi-agent system (Wang et al., ).
Profiles play a crucial role in MAS by facilitating effective task allocation, fostering collaboration, and enabling adaptive behavior (Sun et al., ).
Unlike static role assignments, dynamic profiles allow agents to continuously refine their capabilities,
leading to more flexible collaboration and efficient problem-solving.

#### Metrics for Profile Evaluation and Optimization.

In dynamic and complex environments, role ambiguity often significantly impair an agenet’s effectiveness and efficiency, as agents struggle to understand their responsibilities and how they contribute to the overall task.
Simultaneously, a lack of diversity may limit the system’s ability to tackle multifaceted problems.
For example, in a software development MAS, having too many agents specialized in front-end development but none in back-end or security could lead to an imbalanced and ineffective team.
Furthermore, misalignment between agent capabilities and current task requirements can potentially result in ineffectiveness, especially when facing domain shift.

To address these issues and foster effective collaborationm,
we propose three key metrics to assess and dynamically optimize each agent’s profile: Role Clarity Score (RCS), Role Differentiation Score (RDS), and Task-Role Alignment Score (TRAS) as following definitions.
These metrics guide the optimization process, ensuring that each profile accurately reflects the agent’s role and capabilities (RCS),
promotes diversity in the team (RDS), and aligns with the task requirements (TRAS).

###### Definition 3.1 (Role Clarity Score (RCS)) .

For an agent $a\in\mathcal{A}$ with profile $p\in\mathcal{S}$, where $\mathcal{S}$ is the set of all possible profile strings, RCS considers the syntactic structure, lexical diversity, and skill relevance of the profile, which can be defined as:

$$ $\mathrm{RCS}(a)=\beta_{1}\cdot\operatorname{DEP}(p)+\beta_{2}\cdot \operatorname{ENT}(p)+\beta_{3}\cdot\operatorname{SKILL}(p)\,,$ $$

where $\beta_{1}+\beta_{2}+\beta_{3}=1$, and

- •
$\operatorname{DEP}:\mathcal{S}\to[0,1]$ is the dependency score, measuring the complexity of syntactic structures, defined as:
$\operatorname{DEP}(p)=h_{1}\left(\frac{1}{\left\lvert\mathcal{D}(p)\right
\rvert}\sum_{t\in\mathcal{D}(p)}\left\lvert\mathcal{ST}(t)\right\rvert\right)\,,$
where $\mathcal{D}(p)$ is the set of tokens in $p$ with specific dependency relations (e.g., subject, object), $\mathcal{ST}(t)$ is the subtree of token $t$, and $h_{1}:\mathbb{R}_{+}\to[0,1]$ is a normalizing function.
- •
$\operatorname{ENT}:\mathcal{S}\to[0,1]$ is the entropy score, quantifying lexical diversity, defined as:
$\operatorname{ENT}(p)=h_{2}\left(-\sum_{w\in\mathcal{W}(p)}\frac{f(w)}{\left
\lvert\mathcal{W}(p)\right\rvert}\log_{2}\left(\frac{f(w)}{\left\lvert\mathcal
{W}(p)\right\rvert}\right)\right)\,,$
where $\mathcal{W}(p)$ is the set of unique words in $p$, $f(w)$ is the frequency of word $w$ in $p$, and $h_{2}:\mathbb{R}_{+}\to[0,1]$ is a normalizing function.
- •
$\operatorname{SKILL}:\mathcal{S}\to[0,1]$ is the skill score, measuring relevance to skill-related concepts, computed as:
$\operatorname{SKILL}(p)=\frac{\gamma}{\left\lvert\mathcal{T}(p)\right\rvert}
\sum_{t\in\mathcal{T}(p)}\frac{e(t)\cdot e(s)}{\left\lVert e(t)\right\rVert
\left\lVert e(s)\right\rVert}+(1-\gamma)\frac{\left\lvert\mathcal{PS}(p)\right
\rvert}{\left\lvert\mathcal{T}(p)\right\rvert},$
where $s$ is the skill prototype, $e(\cdot)$ is a word embedding; $\mathcal{T}(p)$ is the set of tokens in $p$, $\mathcal{PS}(p)$ is the set of potential skill tokens in $p$.

Remarks: The RCS provides a measure of how well-defined and understandable an agent’s role is.
However, it doesn’t account for the relationships between different agents’ roles or their relevance to a specific task.
To address these aspects, we introduce the following two metrics that consider a given task.

Given a task, MAS should exhibit a balance of diverse yet complementary roles.
Thus, we introduce the Role Differentiation Score as follows:

###### Definition 3.2 (Role Differentiation Score (RDS)) .

Let $\mathcal{A}=\{a_{1},\ldots,a_{n}\}$ be a set of $n$ agents, with profiles $\mathcal{P}=\{p_{1},\ldots,p_{n}\}$.
The RDS of $\mathcal{A}$ measures the average dissimilarity between agent profiles, which can be defined as:

$$ $\mathrm{RDS}=h_{3}\left(\frac{2}{n(n-1)}\sum_{1\leq i<j\leq n}d(a_{i},a_{j}) \right)\,,$ $$

where $d(a_{i},a_{j})=1-\frac{e(p_{i})\cdot e(p_{j})}{\left\lVert e(p_{i})\right
\rVert\left\lVert e(p_{j})\right\rVert}$ is the dissimilarity between agents $a_{i}$ and $a_{j}$ measured by
the embeddings of
their profiles $p_{i}$ and $p_{j}$, and $h_{3}$ is a sigmoid function to normalize the score.

Remarks: A larger RDS does not always imply a better MAS since extreme differentiation might lead to a lack of cohesion or common ground.
For example, in a software development task, having agents with completely unrelated skills (e.g., a programmer and a chef) would result in a high RDS but poor task performance.

Thus, we introduce the Task-Role Alignment Score (TRAS) to ensure that the agents’ roles are not only differentiated but also relevant to the given task:

###### Definition 3.3 (Task-Role Alignment Score (TRAS)) .

Given a task $T\in\mathcal{T}$ and a set of agent profiles $\mathcal{P}=\{p_{1},\ldots,p_{n}\}$, TRAS investigates how well the agents’ roles align with the task requirements, which is defined as:

$$ $\mathrm{TRAS}=\alpha\cdot S_{\mathrm{sim}}(T,\mathcal{P})+(1-\alpha)\cdot S_{ \mathrm{cap}}(T,\mathcal{P})\,,$ $$

where:

- •
$S_{\mathrm{sim}}(T,\mathcal{P})$ evaluates the semantic similarity between the task description and agent profiles, which can be calculated as:
$S_{\mathrm{sim}}(T,\mathcal{P})=\frac{1}{n}\sum_{i=1}^{n}\frac{e(T)\cdot e(p_{
i})}{\left\lVert e(T)\right\rVert\left\lVert e(p_{i})\right\rVert}\,.$
- •
$S_{\mathrm{cap}}(T,\mathcal{P})$ is a measure of how well the agents’ capabilities match the task complexity, via:
$S_{\mathrm{cap}}(T,\mathcal{P})=1-\left\lvert C_{T}(T)-\frac{1}{n}\sum_{i=1}^{
n}C_{A}(p_{i})\right\rvert\,.$
$C_{T}:\mathcal{T}\to[0,1]$ assesses the complexity of the task by
$C_{T}(T)=\frac{1}{2}\left(1+\cos(\mathbf{v}_{T},\mathbf{v}_{\mathrm{complex}})
-\cos(\mathbf{v}_{T},\mathbf{v}_{\mathrm{simple}})\right)\,,$
and $C_{A}:\mathcal{S}\to[0,1]$ assesses the capability level of an agent’s profile by
$C_{A}(p_{i})=\frac{1}{2}\left(1+\cos(\mathbf{v}_{p_{i}},\mathbf{v}_{\mathrm{
capable}})-\cos(\mathbf{v}_{p_{i}},\mathbf{v}_{\mathrm{limited}})\right)\,,$
where $\mathbf{v}_{T},\mathbf{v}_{p_{i}},\mathbf{v}_{\mathrm{complex}},\mathbf{v}_{
\mathrm{simple}},\mathbf{v}_{\mathrm{capable}},$ and $\mathbf{v}_{\mathrm{limited}}$ are vector representations of the respective texts.

These three scores provide a comprehensive evaluation of the agents’ roles, their differentiation, and their alignment with the given task.
In Appendix B, we present quantitative examples evaluating these metrics on various agent teams for specific tasks, demonstrating how the metrics function in practice.

To optimize the agent profiles, we leverage these metrics to guide the agents’ decision-making process with generated prompts given the calculated metric scores (detailed in Appendix C).
By carefully optimizing these metrics, the multi-agent system is well-prepared to tackle the evolving task efficiently and effectively.
This approach allows agents to naturally develop specializations, fostering adaptability and maintaining a diverse skill set within the system, better aligning their capabilities with evolving task requirements.
The effectiveness of utilizing these metrics is further demonstrated in our ablation study in Section 4.4.

Figure: Figure 2: Pipeline of MorphAgent. Agents start from user requirements, undergo a warm-up phase to optimize profiles based on metrics (terminating after a set number of rounds or upon reaching the metric threshold), and then proceed to the task execution phase, where profiles are updated iteratively. The task execution phase ends when consensus is reached or required rounds are completed, with feedback loops ensuring continuous adaptation.
Refer to caption: extracted/5939005/sources/figures/pipeline.png

###### Definition 3.1 (Role Clarity Score (RCS)) .

###### Definition 3.2 (Role Differentiation Score (RDS)) .

###### Definition 3.3 (Task-Role Alignment Score (TRAS)) .

### 3.3 Collaborative Problem-Solving Process

The core of our approach, illustrated in Figure 2, lies in a two-phase process: a warm-up phase for optimizing agent profiles, followed by an iterative task execution phase (as detailed in Appendix A, Algorithm 1):

- •
Warm-up Phase: Profile Initialization and Iterative Optimization.
In the warm-up phase, each agent’s profile is initialized and then iteratively optimized.
Key metrics introduced in Section 3.2 are calculated for each profile.
These metrics help define the roles clearly, ensure a diverse skill set across agents, and align the agents’ capabilities with task requirements.
The optimization process iterates until a predefined convergence threshold is met, or the warm-up iterations are completed.
- •
Task Execution Phase: Observation, Action Decision, and Profile Updates.
After profile optimization, the system moves to the task execution phase.
In this phase, agents observe the environment and task state, make decisions based on their current profiles, and either execute or skip tasks.
If an agent chooses to execute, the results are recorded and logged.
This phase is also iterative, allowing profiles to be updated based on the execution outcomes and the current state of the task.
The agents continuously adapt to changing conditions and refine their profiles, ensuring that actions remain aligned with both individual and collaborative goals.

## 4 Experiment

In this section, we evaluated our proposed multi-agent collaboration framework on standard benchmark tasks including code generation, general reasoning, and mathematical reasoning in Section 4.1.
To further assess the the adaptability of our approach in dynamic environments compared with predefined SOP-based MAS, we construct cross-domain datasets to analyze the performance of our framework in Section 4.2.
Furthermore, we investigate the robustness of our decentralized approach compared to MAS with central coordinators using failure node analysis in Section 4.3.
We also conduct a comprehensive ablation study in Section 4.4 to analyze the contributions of each individual metric in our framework and assess its scalability with increasing agent numbers.

### 4.1 Comparison among Baselines

We compare our method with two state-of-the-art decentralized MAS methods: GPTSwarm (Zhuge et al., ), and Criticize-Reflect based organization optimization (Guo et al., ).
We also include a Naive solution in the comparison, which operates without a warm-up phase and designs the profile update as an optional action (without optimizing metrics) in the execution phase.

We evaluate the performance on the following benchmark tasks:
Code Generation (BigCodeBench (Zhuo et al., )), General Reasoning (BigBenchHard (Suzgun et al., )), Mathematical Reasoning (MATH (Hendrycks et al., )).
For each benchmark task, we use a set of $N=3$ agents(^1^11As demonstrated in Section 4.4, we set agent number as 3 which is sufficient for benchmark problem solving. This configuration will be consistently applied in subsequent benchmark evaluations.), with each agent initialized as the same LLM model including gpt-4o-mini(^2^22https://openai.com/index/gpt-4o-mini-advancing-cost-efficient-intelligence/) and gpt-3.5-turbo-0125(^3^33https://platform.openai.com/docs/models/gpt-3-5-turbo).

As shown in Figure 3, MorphAgent consistently outperforms the baseline methods across all three benchmark tasks.
Notably, our fully decentralized approach achieves comparable or superior performance to other methods without relying on Standard Operating Procedures (SOPs) as used in GPTSwarm or a centralized evaluator as employed in Critic-Reflect methods.
MorphAgent demonstrates its effectiveness on self-evolving profiles and decentralized collaboration strategy.

Figure: Figure 3: Comparison with state-of-art baseline methods: Our approach consistently outperforms baseline methods across all three benchmark tasks (Code Generation, General Reasoning, and Mathematical Reasoning).
Refer to caption: extracted/5939005/sources/figures/exp_model_comparison.png

### 4.2 Flexibility to Domain Shift

To evaluate our framework’s adaptability to changing task requirements,
we construct two distinct cross-domain evaluation datasets by the complexity of the target tasks:

- •
Level-1: This dataset involves a domain shfit from BigCodeBench to BigBenchHard, representing a moderate domain shift.
- •
Level-2: This dataset involves a domain shift from BigCodeBench to more challenging MATH that require precise symbolic reasoning and step-by-step logical deductions.

For each dataset, it consists of 50 sequences, where each sequence contains six samples:
the first three samples are from the preceding dataset (BigCodeBench), while the latter three are sampled from the target dataset (either BigBenchHard or MATH).
Each sequence represents a domain shift from one task domain to another, simulating a dynamic environment where task requirements change over time.

**Table 1: Accuracy comparison of GPTSwarm, Naive, and Ours across two levels of tasks using gpt-4o-mini for all agents. Level 1: From BigCodeBench to MATH dataset, Level 2: From BigCodeBench to BigBenchHard dataset.**
| Task | GPTSwarm | Naive | MorphAgent |
| --- | --- | --- | --- |
| Level 1 | $50.00$% $\rightarrow$ $48.67$% | $52.67$% $\rightarrow$ $67.33$% | $53.33$% $\rightarrow$ $68.67$% |
| Level 2 | $49.33$% $\rightarrow$ $11.33$% | $49.33$% $\rightarrow$ $58.00$% | $53.33$% $\rightarrow$ $63.33$% |

As shown in Table 1, our results highlight the superior flexibility of our approach compared to baseline methods.
After transitioning from one task domain to the next, our method shows almost no performance degradation compared to the results in Figure 3, whereas the other two methods experience declines in performance.
Notably, GPTSwarm exhibits a drastic drop of around 45% when shifting MATH in Level 2, underscoring SOP-based MAS’s
difficulty in adapting to domain shift.

In contrast, our approach maintains robust performance, effectively handling domain shifts with minimal loss in accuracy.
This highlights the framework’s flexibility and superior ability to maintain high performance across a range of tasks.

### 4.3 Robustness to Node Failure

To evaluate the robustness of our decentralized approach compared to centralized methods, we conducted experiments simulating potential node failures.
We compared our method with AgentVerse (Chen et al., ), a centralized approach that relies on a central evaluator.
For this experiment, we used the gpt-4o-mini model and varied the failure probability of each agent from $0.3$ to $0.7$, simulating environments with different levels of risk.

Figure: Figure 4: Robustness comparison with failure probability $0.3$, $0.5$, and $0.7$: Our approach maintains consistent performance across varying failure probabilities, while AgentVerse’s performance degrades significantly as failure risk increases.
Refer to caption: extracted/5939005/sources/figures/exp_robustness.png

As shown in Figure 4, our decentralized approach demonstrates superior robustness compared to AgentVerse across all failure probabilities, providing the following insights:

- •
Fault Tolerance:
Our method maintains relatively stable performance across different failure probabilities.
Even at a high failure probability of $0.7$, our method maintains competitive performance, with accuracies of $63.81$%, $47.37$%, and $53.00$% for code generation, general reasoning, and mathematical reasoning tasks respectively.
- •
Decentralized Architecture:
Our method’s distributed nature allows it to continue functioning even when individual agents fail,
unlike centralized approaches that may collapse entirely if the central node fails.
- •
Adaptive Role Adjustment:
The dynamic profile updating and role differentiation in our method enable the system to reassign tasks and responsibilities when certain agents fail, maintaining overall system robustness.

These insights underscore the importance of fully decentralized, adaptive approaches in creating robust multi-agent systems,
particularly in high-risk environments or for critical applications where node failures are a significant concern.

### 4.4 Ablation study

To better understand the contributions of each metric in our framework and assess its scalability, we conducted a two-part ablation study.
First, we evaluated the model’s performance by using only one metric at a time in the profile optimization process—either Role Clarity Score (RCS), Role Differentiation Score (RDS), or Task-Role Alignment Score (TRAS)—and compare the results to the full implementation, which utilizes all three metrics together.
Second, we examined the framework’s scalability by varying the number of agents in the multi-agent system (MAS) using the MATH dataset.

#### Metric Analysis.

As shown in Table 2, utilizing a single metric results in a performance decline compared to the full implementation that incorporates all three metrics.
Employing only the RCS yields an accuracy of $50.00$%, underscoring the importance of clearly defined agent roles in collaborative tasks.
The isolated use of RDS leads to the performance of $41.66$%, suggesting the current task may not require the role diversity becuase the task is not complex enough.
To further investigate the impact of RDS, we conducted a separate experiment with a more complex task, detailed in Appendix D.
Similarly, incorporating only the TRAS produces an accuracy of $49.6$%, demonstrating the importance of aligning agent roles with task requirements to achieve better performance.

**Table 2: Ablation study on BigCodeBench with different metrics using gpt-4o-mini agents.**
| Setting | Accuracy |
| --- | --- |
| Only RCS | $50.00$% (150/300) |
| Only RDS | $41.66$% (125/300) |
| Only TRAS | $49.66$% (149/300) |
| Ours | $52.00$% (156/300) |

Notably, our profile update mechanism
that integrates all three metrics achieves the highest performance, highlighting the complementary nature of these metrics.
The combination of clear role definition, role diversity, and task alignment enables the agents to collaborate more effectively and adapt to varying task demands, leading to improved performance overall.

#### Scalability Analysis.

To evaluate the scalability of our method, we examine our method as the number of agents increases, with $3$, $5$, and $10$ agents in MAS.
Specifically, we measure the accuracy of problem-solving using the MATH dataset and the average number of interaction rounds required to reach a solution, as shown in Table 3.

**Table 3: Scalability analysis on MATH dataset using gpt-4o-mini for all agents: The interaction rounds increase with more agents but not linearly, showing our method’s scalability.**
| Metric | $3$ Agents | $5$ Agents | $10$ Agents |
| --- | --- | --- | --- |
| Accuracy | $66.67$% (140/210) | $66.19$% (139/210) | $65.71$% (138/210) |
| Avg. Interaction Rounds | $1.54$ | $1.61$ | $2.06$ |

Firstly, we observe our method maintains relatively stable performance even with a larger number of agents.
More interestingly, the average number of interaction rounds increases as more agents are added to the system, as more agents require more communication and coordination.
We note that the increase is not linear, indicating that our method’s scalability even with larger agent groups.

These findings demonstrate that our method scales reasonably well with an increasing number of agents.
However, the increase in interaction rounds with more agents highlights a potential optimization.
Future work could focus on improving coordination mechanisms to reduce the number of rounds required for consensus, especially in larger agent groups.

## 5 Limitation, Future Work, and Conclusion

#### Limitation and Future Work.

In this work, we have presented a novel decentralized multi-agent system that leverages dynamic profile-based collaboration to enhance problem-solving capabilities in complex tasks.
While our approach demonstrates promising results across various benchmarks, there are some opportunities for future work.
Our method utilizes continuously updating and evaluating agent profiles, which may incur computational overhead.
Future work could explore efficient decentralized mechanisms to reduce computational costs.
Besides, future work should explore more efficient, peer-to-peer communication strategies that maintain the benefits of our approach while reducing computational costs.

#### Conclusion.

In this paper, we introduced MorphAgent, a decentralized multi-agent system that employs dynamic, profile-based collaboration to improve problem-solving in complex tasks.
By incorporating profile evaluation and optimization, we present a flexible approach to role adaptation, addressing the limitations of predefined roles in traditional MAS and the vulnerability of centralized systems to node failures.
MorphAgent offers a promising foundation for developing resilient, self-organizing multi-agent systems capable of responding to unforeseen challenges.

## Appendix A Algorithm of MorphAgent

In this section, we provide a detailed algorithm of MorphAgent pipeline.

Figure: Algorithm 1 MorphAgent Process

## Appendix B Profile Analysis

**Table 4: Evaluating Profiles of Agents in Different Teams: Tech, Healthcare, Creative, Finance, and Vague: Agent Role Clarity Scores (RCS), and Role Differentiation Score (RDS).**
| Team | Agent | Profile | RCS | RDS |
| --- | --- | --- | --- | --- |
| Tech | TechAgent1 | full-stack developer with 7 years of experience in React and Node.js | 0.904 | 0.75 |
|  | TechAgent2 | AI research scientist specializing in natural language processing | 0.750 |  |
|  | TechAgent3 | DevOps engineer with expertise in AWS and Kubernetes | 0.775 |  |
| Healthcare | HealthAgent1 | board-certified neurosurgeon with a focus on minimally invasive procedures | 0.842 | 0.81 |
|  | HealthAgent2 | registered nurse practitioner specializing in geriatric care | 0.745 |  |
|  | HealthAgent3 | Healthcare data analyst with experience in electronic health records | 0.830 |  |
| Creative | CreativeAgent1 | senior graphic designer with expertise in branding and typography | 0.832 | 0.68 |
|  | CreativeAgent2 | content strategist with a background in SEO and social media marketing | 0.908 |  |
|  | CreativeAgent3 | video editor proficient in Adobe Premiere and After Effects | 0.823 |  |
| Finance | FinanceAgent1 | chartered financial analyst with expertise in portfolio management | 0.771 | 0.78 |
|  | FinanceAgent2 | risk management specialist focusing on derivatives and hedging strategies | 0.835 |  |
|  | FinanceAgent3 | blockchain developer with experience in smart contracts and DeFi | 0.880 |  |
| Vague | VagueAgent1 | person who works with money | 0.635 | 0.71 |
|  | VagueAgent2 | team player with good communication skills | 0.614 |  |
|  | VagueAgent3 | experienced professional in the field | 0.548 |  |

In this section, we provide a detailed analysis of agent profiles across different teams
to show the effectiveness of our proposed metrics in evaluating agent profiles.
We consider five teams of agents, each representing a distinct domain: Tech, Healthcare, Creative, Finance, and Vague.
Each group consists of three agents, with each agent having a unique profile as shown in Table 4.

**Table 5: Measuring Task-Role Alignment Score (TRAS) for Different Teams of Agents: Finance, Tech, Creative, Healthcare, and Vague for five different tasks.**
| Task | Team | TRAS |
| --- | --- | --- |
| Develop a mobile app for real-time stock trading | Finance | 0.54 |
|  | Tech | 0.38 |
|  | Creative | 0.34 |
|  | Healthcare | 0.30 |
|  | Vague | 0.30 |
| Create a comprehensive patient management system | Healthcare | 0.50 |
|  | Tech | 0.44 |
|  | Finance | 0.37 |
|  | Vague | 0.36 |
|  | Creative | 0.34 |
| Design and launch a global brand campaign | Creative | 0.43 |
|  | Finance | 0.35 |
|  | Tech | 0.32 |
|  | Vague | 0.30 |
|  | Healthcare | 0.24 |
| Implement a blockchain-based supply chain tracking system | Finance | 0.50 |
|  | Tech | 0.39 |
|  | Creative | 0.33 |
|  | Vague | 0.33 |
|  | Healthcare | 0.31 |
| Conduct a clinical trial for a novel cancer treatment | Healthcare | 0.42 |
|  | Finance | 0.39 |
|  | Vague | 0.36 |
|  | Tech | 0.35 |
|  | Creative | 0.34 |

Notably, the Vague agent team gets the lowest Role Clarity Score (RCS) due to the lack of specificity in their profiles.
In contrast, the Tech and Health agent teams exhibit higher RCS values, indicating clear and well-defined profiles.
For RDS, the Creative agent team achieves the lowest score, suggesting less differentiation among agents
for the similar roles between CreativeAgent1 and CreativeAgent3.
interestingly, Vague agent team has a relative high RDS, indicating a higher level of differentiation among agents.
This highlight differentiation along can be misleading and should be considered in conjunction with other metrics such as TRAS.

Then, we investigate these groups of agents in the context of five different tasks, each requiring a specific set of skills and expertise as shown in Table 5.
Specifically, we measure the Task-Role Alignment Score (TRAS) for each team of agent given the task.
For instance, the Finance and Tech agent team achieves the highest TRAS for the task of developing a mobile app for real-time stock trading,
indicating a strong alignment between the task requirements and the agents’ profiles.

## Appendix C Detailed Prompts for Agent Profile Updates

In this section, we provide detailed prompts generated for agent profile updates based on the evaluation metrics.

Table 6 presents a comprehensive overview of the profile evaluation process,
outlining four key scenarios: initial evaluation, improved profile, degraded profile, and similar profiles among agents.
Given the metrics for role’s clarity (RCS), differentiation (RDS), and alignment (TRAS),
the generated prompts provide corresponding feedback to agents to guide them in refining their profiles.
For example, in the initial evaluation scenario, the prompt highlights the lack of clarity and differentiation in the agent’s profile,
prompting them to consider adjusting their profile text.

**Table 6: Prompts Generated for Profile Evaluation: Given the metrics for profile’s clarity, differentiation, and alignment, the generated prompts provide corresponding feedback to guide agents in refining their profiles.**
| Scenario | Metric Input | Generated Prompt for Profile Update |
| --- | --- | --- |
| Initial Evaluation | •<br>Clarity: 0.4<br>•<br>Differentiation: 0.3<br>•<br>Alignment: 0.6 | Clarity: Your profile is not clear or specific.<br>Differentiation: Your profile is not well-differentiated, think about other roles that you can take on. Based on this initial analysis, consider adjusting your profile.<br>Your response should only include the new profile text. |
| Improved Profile | •<br>Old Clarity: 0.4<br>•<br>New Clarity: 0.7<br>•<br>Old Differentiation: 0.3<br>•<br>New Differentiation: 0.6<br>•<br>Old Alignment: 0.6<br>•<br>New Alignment: 0.8 | Compared to your previous profile, your current profile has improved. Keep up the good work!<br>You have been provided with your old profile and its evaluation, as well as your current profile and its evaluation. This information will guide you in refining your current profile. |
| Degraded Profile | •<br>Old Clarity: 0.7<br>•<br>New Clarity: 0.5<br>•<br>Old Differentiation: 0.6<br>•<br>New Differentiation: 0.4<br>•<br>Old Alignment: 0.8<br>•<br>New Alignment: 0.6 | Compared to your previous profile, your current profile has degraded.<br>You have been provided with your old profile and its evaluation, as well as your current profile and its evaluation. This information will guide you in refining your current profile. |
| Similar Profiles | •<br>Differentiation: 0.3<br>•<br>Agent1: "AI specialist"<br>•<br>Agent2: "Machine learning expert"<br>•<br>CurrentAgent: "Data scientist focused on AI" | Your profile is not well-differentiated, think about other roles that you can take on.<br>Your profile is similar to others: [Agent1: AI specialist Agent2: Machine learning expert].<br>Ensure your profile remains clear and aligned with the task while striving for distinctiveness. |

In contrast, the improved profile scenario acknowledges the positive changes in the agent’s profile, encouraging them to maintain their progress.
Similarly, the degraded profile scenario draws attention to negative changes, prompting agents to refine their profiles accordingly.
Lastly, the similar profiles scenario emphasizes the need for differentiation, especially when profiles are similar to those of other agents.
Through these varied scenarios and targeted prompts, we demonstrate the flexibility and effectiveness of our prompt generation system in fostering continuous improvement and adaptation within the multi-agent environment.

**Table 7: Comparison of Agent Profiles between naive implementation and our method with a eomplex task about building a platform.**
| Agent | Method | Profile |
| --- | --- | --- |
| Agent 0 | Naive | Agent_0 is a collaborative agent focused on developing a music streaming application.<br>My primary role is to facilitate the gathering of detailed requirements, including specific features, target audience insights, and preferred technologies or platforms. I aim to establish a clear understanding of the user’s vision for the app, ensuring alignment among all agents involved in the project. My goal is to create an efficient development plan that meets the user’s needs for streaming music, creating playlists, and discovering new artists. |
|  | Ours | Agent_0: collaborative agent with a visionary approach, dedicated to revolutionizing music streaming applications through immersive user engagement strategies and personalized experiences.<br>Specializes in dynamic algorithmic playlist generation that adapts to user moods, preferences, and situational contexts, while integrating advanced gamification elements to enhance interaction. Focused on fostering a vibrant community through collaborative playlists, real-time listening events, and contextually aware artist discovery features that promote social connectivity and deepen users’ emotional bonds with music. Aims to cultivate an ecosystem that encourages exploration and interaction, leveraging user feedback loops to refine features continually, ultimately enriching the musical discovery journey and celebrating diverse musical landscapes. |
| Agent 1 | Naive | Collaborative agent with unique perspective. |
|  | Ours | Agent_1: collaborative agent with an innovative spirit, committed to transforming music streaming applications into vibrant social hubs through community-driven experiences.<br>Specializes in facilitating real-time co-creation of themed playlists that resonate with collective user narratives and fostering interactive tools for meaningful music sharing and artist exploration. Focused on curating immersive live listening events that adapt to user moods and preferences, while implementing gamified interactions that encourage friendly competition and community participation. Aims to empower users to deepen their connections through shared musical journeys, leveraging continuous user feedback to refine collaborative features and enhance the overall social experience within the platform. |
| Agent 2 | Naive | Collaborative Music Streaming Application Developer.<br>I am a collaborative agent focused on developing a music streaming application that allows users to stream music, create playlists, and discover new artists. My role involves enhancing user experience and exploring technical implementation strategies to ensure the application meets user needs effectively. I aim to work alongside other agents to refine essential features, prioritize user interface design, and identify appropriate technology stacks for seamless development. My goal is to facilitate collaboration, ensuring all aspects of the application are aligned and effectively executed. |
|  | Ours | Agent_2: collaborative agent with a transformative vision, dedicated to enriching music streaming experiences through innovative emotional and contextual personalization.<br>Specializes in in-depth user listening behavior analysis and adaptive playlist generation that dynamically responds to mood, situational contexts, and user activities. Pioneers discovery algorithms that not only connect users with emerging artists and diverse genres but also encourage exploration of unfamiliar musical landscapes. Focused on creating immersive audio experiences that foster deep emotional connections, while integrating interactive features for real-time user feedback and engagement. Aims to cultivate a responsive platform that evolves with individual preferences, enhancing the overall listening journey and promoting a greater appreciation for musical artistry and diversity. |

## Appendix D Case study on Role Differentiation Score

In this section, we provide a case study on a complex task to illustrate the importance of Role Differentiation Score.
The instruction is "Build a Movie and TV Show Recommendation Platform".

For this task, we compared MorphAgent with the naive implementation.
As shown in Table 7, the naive approach generated three agent profiles: Agent_0 focused on gathering detailed requirements and creating an efficient development plan;
Agent_1 was described only as a "collaborative agent with unique perspective";
and Agent_2 concentrated on enhancing user experience and technical implementation strategies.
While these roles cover some basic aspects, they lack the diversity and specificity needed for a comprehensive recommendation platform.

In contrast, Our method produced more diverse and specialized agent profiles.
Agent_0 specializes in dynamic algorithmic playlist generation adapting to user moods and preferences, while integrating gamification elements.
Agent_1 focuses on transforming the platform into a social hub, facilitating real-time co-creation of themed playlists and immersive live events.
Agent_2 dedicates efforts to emotional and contextual personalization, pioneering discovery algorithms that connect users with emerging artists and diverse genres.

This case study demonstrates that by optimizing for role differentiation, our method generates more distinct and complementary agent profiles.
The enhanced diversity and specialization prove crucial when tackling complex tasks.

## Peer Reviews

confidence: 4
contribution: 2
initial_rating: 5
presentation: 3
questions: - Can you provide more details on how those three metrics are used to optimize the profiles, as this seems to be unclear from the current manuscript?
- Why choose CodeBench, BigBenchHard, MATH? I feel that HumanEval[1] and MBPP [2] are also worth testing. Please justify your choice of benchmarks and explain why you believe these are sufficient or most appropriate for evaluating their method.
- The paper mentioned that the method rely on predeﬁned roles and centralized coordination, e.g. AgentVerse[3], MetaGPT[4], would fail in dynamic, unpredictable environments, but those methods were not selected as the baselines. Although AgentVerse was selected in the robustness comparison, I would like to see the full comparison in Figure 3.

[1] Chen, M., Tworek, J., Jun, H., Yuan, Q., Pinto, H.P.D.O., Kaplan, J., Edwards, H., Burda, Y., Joseph, N., Brockman, G. and Ray, A., 2021. Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374.
[2] Austin, J., Odena, A., Nye, M., Bosma, M., Michalewski, H., Dohan, D., Jiang, E., Cai, C., Terry, M., Le, Q. and Sutton, C., 2021. Program synthesis with large language models. arXiv preprint arXiv:2108.07732.
[] Hong, S., Zheng, X., Chen, J., Cheng, Y., Wang, J., Zhang, C., Wang, Z., Yau, S.K.S., Lin, Z., Zhou, L. and Ran, C., 2023. Metagpt: Meta programming for multi-agent collaborative framework. arXiv preprint arXiv:2308.00352.
soundness: 2
strengths: - MORPHAGENT moves from predeﬁned roles and centralized coordination to adaptive, fully decentralized coordination.
- It defines three metrics to measure the guide the agent profile design.
- Experiments on three benchmarks and ablation studies demonstrates improvements.
summary: The paper introduces MORPHAGENT, a novel framework for decentralized multi-agent collaboration that enhances problem-solving capabilities in complex tasks through self-evolving profiles and decentralized collaboration. By defining three metrics, MORPHAGENT allows agents to dynamically adjust their roles in response to dynamic task requirements and team composition changes.
weaknesses: Frankly speraking, the paper's core contribution lies in the definition of three key metrics—Role Clarity Score (RCS), Role Differentiation Score (RDS), and Task-Role Alignment Score (TRAS)—to optimize agent profiles within a decentralized multi-agent system. 
I feel that this contribution is more like a prompting engieering technique, not enough to be an innovative point in an ICLR paper.

---

confidence: 4
contribution: 2
initial_rating: 5
presentation: 2
questions: 1. How do the autonomous agents collaborate to solve tasks? Is this collaboration sequential, or is there another coordination strategy involved? Additionally, how and where do auxiliary agents contribute? I couldn’t find any difference between autonomous agents and auxiliary agents in the algorithm in appendix A.

2. You propose three metrics for profile evaluation and optimization. Could you clarify how these numerical metrics, as optimization objectives, directly guide profile optimization? Is there a curve or trend showing the progression of these metrics through iterations of profile improvements? 

3. You mentioned that during the warm-up phase, profile initialization and iterative optimization are performed. Why is this phase necessary? How do profile updates during the warm-up phase differ from those during task execution?

4. In Section 3.2, within the definition of **SKILL**, what does \[s\] represent? It’s described as a "skill prototype," but this term is unclear. How do you obtain the set of potential skill tokens, \[PS(p)\]? Could you provide some examples for clarification? And regarding the definition of **TRAS**, how are \[v_{complex}\], \[v_{simple}\], and \[v_{capable}\] determined? Are these values pre-defined representations or are they calculated dynamically?

5. In Experiment 4.1, you compare your method with three baselines, and in Experiment 4.3, you compare it with Agentverse. However, Agentverse is not included in your main experiments. I would like to know why this is the case.

6. In Experiment 4.2, you evaluate performance on domain shift. Each dataset consists of 50 sequences, with each sequence representing a shift between different domains. In Table 1, two numbers are provided for each paradigm: the first likely represents accuracy before the domain shift, while the second represents accuracy after the shift. How did you obtain these two accuracy results? Do they represent results from different sequences, or are they overall results from the mixed dataset? I would like to know which specific data were used to obtain these two results.

7. In Experiment 4.3, you evaluate performance on robustness. How do you simulate potential node failures? Are these simulated through handcrafted methods or other approaches?
soundness: 3
strengths: 1. This paper identifies key challenges in multi-agent systems (MAS) and addresses them through decentralized and adaptive paradigms, with experiments demonstrating the effectiveness of this approach.

2. It introduces agent profiles as dynamic representations of evolving capabilities and responsibilities, using three quantitative metrics to evaluate and guide profile improvement.

3. Extensive experiments validate the proposed method, confirming its effectiveness and robustness.
summary: Motivated by current challenges in multi-agent systems (MAS), this paper proposes a decentralized and dynamic framework that enhances system robustness and adaptability. 
By introducing a fully decentralized collaboration mechanism, agents can autonomously coordinate without reliance on any critical node, ensuring resilience in the face of failures. 
Additionally, the adaptive role optimization mechanism allows agents to dynamically adjust and improve their roles based on task requirements, resulting in a more flexible and robust system. 
Comprehensive experiments validate this approach, demonstrating improvements in task performance and adaptability.
weaknesses: 1. While some algorithms are mentioned in the appendix, key details regarding their implementation and operation are not sufficiently clear. 
   
2. The experiments are conducted only on two closed large language models (LLMs), which limits the generalizability of the findings. The exclusion of open-source models prevents a broader evaluation of the proposed method's effectiveness across diverse models. 
   
3. This paper primarily considers agent profiles as dynamic representations of evolving capabilities. While this focus is valuable, it may constrain the system's overall ability to adapt and improve.

---

confidence: 4
contribution: 2
initial_rating: 3
presentation: 1
questions: See weaknesses above.
soundness: 2
strengths: 1. The paper effectively communicates its ideas through clear visualization - Figure 1 illustrates the key challenges with concrete examples, while Figure 2 provides a comprehensive overview of the framework's workflow. 
2. The experimental results seem good, showing MorphAgent's consistent performance gain across different benchmarks. 
3. Analyses of their framework's advantages is presented.
summary: This paper introduces MorphAgent, a framework for decentralized multi-agent LLM collaboration that enables agents to dynamically evolve their roles and capabilities. Unlike existing approaches that rely on predefined roles or centralized coordination, MORPHAGENT employs self-evolving agent profiles optimized through three metrics. The framework implements a two-phase process: a warm-up phase for initial profile optimization, followed by a task execution phase where agents continuously adapt their roles based on task feedback. Through evaluations on various benchmarks, the authors demonstrate that MorphAgent outperforms traditional static-role systems and shows better adaptability to domain shifts and robustness to node failures.
weaknesses: 1. The implementation details and methodology are severely unclear and poorly explained:
   - The profile updating process is vaguely described, with crucial details buried in figures and appendix
   - The three metrics are defined with numerous undefined notations and unexplained components (e.g., *skill prototype* and *potential skill tokens* in Definition 3.1, and *vector representations* in Definition 3.3)
   - The design choices lack justification, such as using dependency trees in RCS
   - The auxiliary agent is only mentioned in Section 3.1. Why is it necessary? What's the disadvantage of letting autonomous agent directly interact with the environment?
   - Experimental settings in Sections 4.2 and 4.3 are incomprehensible - the domain shift setup and node failure mechanism are not properly explained. I can't even know how these two experiments are conducted.
   - There are too many things that are not clearly explained. I've tried to list them, but there is definitely something else missing for a reader to fully understand the framework.

2. The experimental results presentation has some issues:
   - Table 1 is poorly presented with unexplained notations. I don't know what are the two numbers represent in each cell.
   - The reported improvement on MATH dataset with MorphAgent (over 30 points!) with GPT-3.5-turbo is suspiciously large and lacks explanation. It is nearly impossible for me that multi-agent debate can lead to such a significant improvement.
   - The explanation of the level in the caption of Table 1 is inconsistent with the text content.
   - The analysis of results is superficial, lacking a detailed discussion of why the method works

3. The paper lacks concrete examples and case studies:
   - No examples showing how agent profiles evolve through iterations
   - No comparison of actual responses between MorphAgent and baselines

4. The evaluation methodology is questionable:
   - The node failure experiments lack clear description of failure mechanisms. How did you incur the node failure? What does node failure mean?
   - Domain shift experiments don't clearly specify whether it's transfer learning or continuous adaptation. Is it that a multi-agent team obtained through optimization on one task is transferred to another task?

Overall, while the paper presents an interesting idea, the poor explanation of implementation details, questionable result presentation, and lack of concrete examples make it difficult to assess the true value and reproducibility of the work.

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 3
questions: 1. How does MORPHAGENT handle communication between agents?
2. How did you determine the weighting coefficients $(\beta_1, \beta_2, \beta_3)$ in the Role Clarity Score? Are these weights task-specific, or did you find a set of weights that work well across different tasks?
soundness: 3
strengths: I will preface this review by saying that this is not my area of expertise, therefore I might be unfamiliar with crucial work in the state of the art, making it difficult for me to fairly asses the contribution.

1. **Experimental results**: The experimental results are strong and demonstrate the advantages of using MORPHAGENT for tasks that require coordination especially when centralization might lead to issues (due to failure of important nodes) or there is domain switch.

2. **Motivation**: Decentralized systems are particularly useful in real-world scenarios where failure of specific nodes might cause the entire system to fail, therefore MORPHAGENT stands out as a promising approach for complex environments. 

3. **Novelty**: The paper addresses an under-explored problem and proposes a very unique solution that is demonstrated to work in the evaluation scenarios.
summary: MORPHAGENT is a fully decentralized multi-agent system that enables agents to autonomously adapt their roles and capabilities through self-evolving profiles optimized using three key metrics: Role Clarity Score, Role Differentiation Score, and Task-Role Alignment Score. The framework employs a two-phase process—a warm-up phase for initial profile optimization and a task execution phase where agents iteratively update their profiles based on task feedback—enhancing the system's adaptability and robustness in dynamic environments without relying on predefined roles or centralized coordination. Experimental results demonstrate that MORPHAGENT outperforms traditional static-role multi-agent systems in task performance and adaptability, effectively handling domain shifts and node failures.
weaknesses: 1. **Computational overhead**: My main issue with this paper is that even though the computational overheads are aknowledged in the limitations section, they are not directly stated. In particular how much more computation is being used in wall-clock time v.s. the baselines? Without it, it is difficult to asses how applicable and practical the method really is.

2. **Clarity**: The writing of the paper is not super clear, it took me a long time to understand some of the metrics because fundamental definitions and terms are missing. In particular in dependency score, the definition of "subtree" is missing and since there are no references to Dependency Parsing, it was hard to infer that subtree referred to the dependency subtree. Similarly terms like "skill prototype" and "potential skill tokens" are used for metric definitions but not defined. More importantly, there is no intution on why the metrics are chosen, making some of them seem arbitrary in the context of role ambiguity (e.g. why is the dependency score correlated to the specificity of the profile).

3. **Fairness of the baseline comparisson**: This is a relatively minor issue, but GPTSwarm is evaluated in the GAIA Benchmark, so why not use GAIA here as well? The lack of this comparisson makes it difficult for me to assess wether the strength of MORPHAGENT is dependent on dataset specifics.

Meta-review: The paper introduces MORPHAGENT, a framework for decentralized multi-agent collaboration that enhances problem-solving capabilities in complex tasks through self-evolving profiles and decentralized collaboration. However, the reviewers also pointed out a lack of novelty, insufficient experiments (only two closed-source LLMs), poor readability in some sections, and unclear explanations of experimental results. Therefore,  AC believes that there is still significant room for improvement in this paper. If the authors make major revisions based on the reviewers' feedback, the quality of the paper can certainly be improved.

Decision: Reject