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.¹⁾ 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.²⁾³⁾⁴⁾

arXiv:2308.10848

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

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.

Recruited experts communicate through configurable structures:

• Horizontal: Peer-to-peer debate where all agents have equal standing
• Vertical: Hierarchical communication with leader-follower dynamics

The group implements the collaboratively decided action in the environment.

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

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

# 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)

• 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

• Chen et al. "AgentVerse: Facilitating Multi-Agent Collaboration and Exploring Emergent Behaviors" (2023)
• AgentVerse GitHub Repository
• Hong et al. "MetaGPT: Meta Programming for Multi-Agent Collaborative Framework" (2023)
• Park et al. "Generative Agents: Interactive Simulacra of Human Behavior" (2023)

• ToolLLM: Mastering 16,000+ Real-World APIs
• ExpeL: Experiential Learning Agents
• RAP: Reasoning via Planning