====== AgentVerse: Facilitating Multi-Agent Collaboration ======

**AgentVerse** is a multi-agent collaboration framework introduced by Chen et al. (2023) that dynamically assembles groups of LLM-powered agents to solve complex tasks.((Chen et al. "AgentVerse: Facilitating Multi-Agent Collaboration and Exploring Emergent Behaviors." [[https://arxiv.org/abs/2308.10848|arXiv:2308.10848]], 2023.)) With **541 citations**, it demonstrates that collaborative agent groups consistently outperform individual agents across diverse benchmarks. The framework draws inspiration from human group dynamics research, enabling emergent social behaviors among autonomous agents.(([[https://github.com/OpenBMB/AgentVerse|AgentVerse GitHub Repository]]))(([[https://arxiv.org/abs/2308.08155|Hong et al. "MetaGPT: Meta Programming for Multi-Agent Collaborative Framework" (2023)]]))(([[https://arxiv.org/abs/2303.17760|Park et al. "Generative Agents: Interactive Simulacra of Human Behavior" (2023)]]))

[[https://arxiv.org/abs/2308.10848|arXiv:2308.10848]]

===== Framework Design =====

AgentVerse operates through four iterative phases that mirror human collaborative problem-solving:

==== Phase 1: Expert Recruitment ====

A recruiter agent $M_r$ dynamically generates expert role descriptions based on the task goal $g$:

$$\mathcal{M} = M_r(g) = \{m_1, m_2, \ldots, m_n\}$$

where each $m_i$ is an agent with a specialized persona. Unlike static multi-agent setups, roles are not predefined but generated on-the-fly, adapting to each task's requirements.

==== Phase 2: Collaborative Decision-Making ====

Recruited experts communicate through configurable structures:
  * **Horizontal**: Peer-to-peer debate where all agents have equal standing
  * **Vertical**: Hierarchical communication with leader-follower dynamics

==== Phase 3: Action Execution ====

The group implements the collaboratively decided action in the environment.

==== Phase 4: Evaluation ====

Outcomes are assessed against the goal, with feedback used to refine group composition for subsequent iterations.

===== Emergent Social Behaviors =====

Agent groups exhibit emergent behaviors that enhance performance:

  * **Cooperative specialization**: Agents naturally divide labor based on expertise
  * **Consensus building**: Groups converge on solutions through structured debate
  * **Error correction**: Agents catch and correct each other's mistakes
  * **Groupthink mitigation**: Diverse role recruitment reduces echo-chamber effects

===== System Architecture =====

<mermaid>
graph TD
    A[Task Goal g] --> B[Recruiter Agent]
    B --> C[Expert Group Assembly]
    C --> D[Agent 1: Role Specialist]
    C --> E[Agent 2: Domain Expert]
    C --> F[Agent N: Task Analyst]
    D --> G[Collaborative Decision-Making]
    E --> G
    F --> G
    G --> H{Communication Structure}
    H -- Horizontal --> I[Peer Debate]
    H -- Vertical --> J[Hierarchical Discussion]
    I --> K[Action Execution]
    J --> K
    K --> L[Environment Feedback]
    L --> M{Goal Achieved?}
    M -- No --> N[Evaluation and Feedback]
    N --> B
    M -- Yes --> O[Final Solution]
</mermaid>

===== Code Example =====

<code python>
# Simplified AgentVerse collaboration loop
class AgentVerse:
    def __init__(self, llm, communication="horizontal", max_rounds=5, max_iterations=10):
        self.llm = llm
        self.communication = communication
        self.max_rounds = max_rounds
        self.max_iterations = max_iterations

    def recruit_experts(self, goal):
        prompt = f"As a recruiter, assemble a team for: {goal}\nList expert roles with descriptions."
        response = self.llm.generate(prompt)
        return self._parse_roles(response)

    def collaborative_decision(self, agents, context):
        history = []
        for round_idx in range(self.max_rounds):
            for agent in agents:
                opinion = agent.respond(context, history)
                history.append((agent.role, opinion))
            if self._consensus_reached(history):
                break
        return self._extract_decision(history)

    def solve(self, goal, environment):
        for iteration in range(self.max_iterations):
            experts = self.recruit_experts(goal)
            decision = self.collaborative_decision(experts, environment.state)
            result = environment.execute(decision)
            if environment.goal_achieved(result):
                return result
            goal = self._refine_goal(goal, result)
</code>

===== Key Results =====

  * AgentVerse groups solved **9/10 challenging tasks** vs. **3/10 for single ReAct agent**
  * Consistent improvement across text understanding, reasoning, coding, and tool use
  * Dynamic recruitment outperforms fixed role assignment
  * Horizontal communication excels at creative tasks; vertical at structured ones (([[https://arxiv.org/abs/2308.10848|Chen et al. "AgentVerse: Facilitating Multi-Agent Collaboration and Exploring Emergent Behaviors" (2023)]]))

===== See Also =====

  * [[toolllm|ToolLLM: Mastering 16,000+ Real-World APIs]]
  * [[expel_experiential_learning|ExpeL: Experiential Learning Agents]]
  * [[reasoning_via_planning|RAP: Reasoning via Planning]]

===== References =====