MorphAgent: Self-Adaptive Multi-Agent System

• MorphAgent is a decentralized, self-adaptive multi-agent system that enables autonomous collaboration in LLM-based environments using evolving agent profiles.
• It leverages three metrics—Role Clarity, Role Differentiation, and Task–Role Alignment—to optimize agent roles and maintain adaptive task alignment.
• The system employs a two-phase workflow of dynamic profile updates and iterative task execution, ensuring robust performance even under high failure probabilities.

MorphAgent is an autonomous, self-organizing, and self-adaptive multi-agent system (MAS) for decentralized agent collaboration, specifically designed for LLM-based environments. It enables agents to dynamically evolve their roles and capabilities via self-evolving agent profiles, guided by three complementary metrics. Distinct from traditional MAS architectures, MorphAgent abolishes predefined roles and centralized coordination, instead achieving robust team-level performance and adaptability to task requirements through decentralized, metric-driven optimization and continuous feedback loops (Lu et al., 2024).

1. Motivation and Problem Framework

LLM-based MAS have historically relied on three paradigms: centralized coordination via a manager agent, predefined workflows or static topologies with fixed roles, and rigid SOP-based pipelines lacking runtime flexibility. These designs constrain individual agent autonomy, inhibit self-organization, and preclude self-adaptability to changing environments or task objectives. MorphAgent is motivated by principles observed in natural swarms, such as ants and birds, seeking to instantiate emergent intelligence in artificial systems through locally-governed, adaptive behaviors. The goals are:

1. Individual autonomy: Agents independently select actions using only locally available information.
2. Self-organization: Team structures and communication patterns emerge without central control.
3. Self-adaptability: Agent roles and skill profiles adapt online to evolving task or environmental demands (Lu et al., 2024).

2. Self-Evolving Agent Profiles

Each agent $a_i$ maintains a dynamic profile $p_i = (f_i,\, c_i,\, r_i)$, comprising:

• $f_i$: functional capabilities (e.g., "Python coding," "legal analysis"),
• $c_i$: contextual parameters (domain-specific preferences or adjustments),
• $r_i$: interaction rules (policies for peer communication).

Profile updates utilize the LLM prompting mechanism, formalized as

$$p_i^t = \psi(o_i^t,\, p_i^{t-1},\, \{\alpha_j^t\}_{j\in \mathcal N_i^t})$$

where $o_i^t$ are local observations, $\{\alpha_j^t\}$ are recent actions of neighboring agents, $\psi$ is the LLM-driven update function, and $\mathcal N_i^t$ denotes the dynamic neighborhood.

Profile refinement is guided by three metrics:

• Role Clarity Score (RCS):

$$\mathrm{RCS}(a_i) = \beta_1\,\mathrm{DEP}(p_i) + \beta_2\,\mathrm{ENT}(p_i) + \beta_3\,\mathrm{SKILL}(p_i)$$

Where $\mathrm{DEP}(p)$: syntactic depth, $\mathrm{ENT}(p)$: lexical entropy, $\mathrm{SKILL}(p)$: cosine similarity with "skill prototype" and count of skill-bearing nouns ($\beta_1 + \beta_2 + \beta_3 = 1$).

• Role Differentiation Score (RDS):

$$\mathrm{RDS} = h\!\Bigl( \frac{2}{n(n-1)}\sum_{1\le i<j\le n} [1-\cos(e(p_i), e(p_j))] \Bigr)$$

Promoting separation in profile embedding space; $h$ is a sigmoid normalizer, $e(\cdot)$ is the sentence embedding.

• Task–Role Alignment Score (TRAS):

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

Where

$$S_{\mathrm{sim}} = \frac{1}{n}\sum_{i=1}^n \cos(e(T), e(p_i)), \quad S_{\mathrm{cap}} = 1-\left| C_T(T) - \frac{1}{n}\sum_{i=1}^n C_A(p_i) \right|$$

$C_T(T)$ and $C_A(p_i)$ are task complexity and agent capability measures, computed via cosine similarities to reference vectors.

3. Two-Phase Decentralized Workflow

MorphAgent employs a two-phase process:

Phase 1: Profile Update Phase

• Agents are initialized with minimal or identical profiles.
• For up to $T_{\max}=5$ rounds (or until all metrics increase by at least 0.1), each agent:
  1. Computes its current RCS, RDS, and TRAS.
  2. Compares scores to previous iterations.
  3. Selects a targeted feedback prompt and uses LLM to update $p_i$.

• Outputs a set of optimized agent profiles.

Phase 2: Task Execution Phase

• Agents iterate through an Observe–Think–Act loop:
  1. Observe shared workspace (problem statement, peer outputs).
  2. Decide (via LLM policy $\pi$) whether to EXECUTE (contribute a result) or SKIP (yield turn).
  3. Act on decision.

• Consensus is reached when all agents consecutively issue SKIP.

• Upon execution failure or disruptive events, agents may invoke a lightweight (single-round) profile update and resume.

4. Team Dynamics and Metric Interplay

Role overlap is explicitly penalized through the RDS metric: agents with highly similar profiles are prompted to differentiate. The interplay among the three core metrics directs profile optimization:

• Overemphasis on RCS can result in homogenous, but well-articulated, agent profiles.
• Overemphasis on RDS leads to maximally separated—but potentially irrelevant—roles.
• TRAS tempers both by aligning profile features with task requirements.

The global objective function formalizing team profile quality is:

$$\sum_{i=1}^n \mathrm{RCS}(a_i) + \lambda_1 \mathrm{RDS} + \lambda_2 \sum_{i=1}^n \mathrm{TRAS}(a_i)$$

where $\lambda_1, \lambda_2$ are hyperparameters. Optimization proceeds by decentralized, gradient-free updates driven by iterative LLM prompting.

5. Empirical Evaluation and Quantitative Results

Experiments incorporate the following evaluation settings:

• Benchmarks: BigCodeBench (code generation; 1140 functions), BigBenchHard (general reasoning), MATH (mathematical reasoning).
• Base LLMs: GPT-4o-mini, DeepSeek-V3, GPT-3.5-Turbo (ablation studies).
• Baselines: GPTSwarm, AgentVerse, AFLOW.
• Dynamic environment: Each agent has per-round failure probability (0 to 0.8) to skip their turn, simulating robustness to node failures.

Key findings:

• On BigCodeBench with no failures, MorphAgent obtains around 52–54% accuracy versus 47–50% for all baselines.
• Under high failure probability (up to 0.8), baselines drop to 1–20% accuracy, while MorphAgent retains 40–54%.
• Across all tested backbones, MorphAgent consistently outperforms existing MAS frameworks.

Ablation results (Section 4.2) demonstrate the necessity of all three metrics:

Setting	GPT-4o-mini	GPT-3.5-Turbo
+ None	50.67%	38.33%
+ RCS only	50.00%	39.33%
+ RDS only	41.66%	37.00%
+ TRAS only	49.66%	35.33%
MorphAgent (all)	52.00%	43.33%

6. Insights, Limitations, and Prospective Directions

Dynamic, self-evolving profiles enable robust self-organization into task-appropriate, complementary roles. Effective MAS operation requires balancing role clarity, inter-agent differentiation, and task-role alignment; reliance on any single metric degrades overall quality. Decentralized, LLM-driven profile updates provide resilience against agent dropouts or execution failures.

Limitations include computational overhead from multiple LLM calls during profile optimization (up to 5 initial rounds) and increasing overhead with large agent counts—albeit with sublinear growth in practice (Appendix A.7).

Prospective directions include the development of more efficient peer-to-peer communication protocols, lightweight embedding-based metric estimators to reduce LLM call volume, adaptive meta-learning of metric weights ($\beta_i, \alpha, \lambda_i$) for task specificity, support for heterogeneous tool-using agents, and formal game-theoretic analysis of profile co-evolution (Lu et al., 2024).